Cataclysm BN
game Class Reference

#include <game.h>

Classes

class  Creature_range
 
class  debug_hour_timer
 
class  draw_callback_t
 
class  monster_range
 
class  non_dead_range
 
class  npc_range
 

Public Types

enum  inventory_item_menu_positon { RIGHT_TERMINAL_EDGE , LEFT_OF_INFO , RIGHT_OF_INFO , LEFT_TERMINAL_EDGE }
 

Public Member Functions

 game ()
 
 ~game ()
 
void load_static_data ()
 Loads static data that does not depend on mods or similar. More...
 
void load_core_data (loading_ui &ui)
 Loads core dynamic data. More...
 
bool is_core_data_loaded () const
 Returns whether the core data is currently loaded. More...
 
bool check_mod_data (const std::vector< mod_id > &opts, loading_ui &ui)
 Check if mods can be successfully loaded. More...
 
void load_world_modfiles (loading_ui &ui)
 Loads core data and mods from the active world. More...
 
std::string get_player_base_save_path () const
 Base path for saving player data. More...
 
std::string get_world_base_save_path () const
 Base path for saving world data. More...
 
bool load_packs (const std::string &msg, const std::vector< mod_id > &packs, loading_ui &ui)
 Load content packs. More...
 
void on_options_changed ()
 Should be invoked whenever options change. More...
 
void setup ()
 
void serialize (std::ostream &fout)
 Saving and loading functions. More...
 
void unserialize (std::istream &fin)
 
void unserialize_master (std::istream &fin)
 
bool dump_stats (const std::string &what, dump_mode mode, const std::vector< std::string > &opts)
 write statistics to stdout and More...
 
bool save ()
 Returns false if saving failed. More...
 
std::vector< std::string > list_active_characters ()
 Returns a list of currently active character saves. More...
 
void write_memorial_file (const std::string &filename, std::string sLastWords)
 Writes information about the character out to a text file timestamped with the time of the file was made. More...
 
bool cleanup_at_end ()
 
void start_calendar ()
 
bool do_turn ()
 MAIN GAME LOOP. More...
 
shared_ptr_fast< ui_adaptorcreate_or_get_main_ui_adaptor ()
 
void invalidate_main_ui_adaptor () const
 
void mark_main_ui_adaptor_resize () const
 
void draw ()
 
void draw_ter (bool draw_sounds=true)
 
void draw_ter (const tripoint &center, bool looking=false, bool draw_sounds=true)
 
void add_draw_callback (shared_ptr_fast< draw_callback_t > cb)
 
void draw_panels (bool force_draw=false)
 
cata::optional< tripointget_veh_dir_indicator_location (bool next) const
 Returns the location where the indicator should go relative to the reality bubble, or nothing to indicate no indicator should be drawn. More...
 
void draw_veh_dir_indicator (bool next)
 
void vertical_move (int z, bool force, bool peeking=false)
 Moves the player vertically. More...
 
void start_hauling (const tripoint &pos)
 
cata::optional< tripointfind_or_make_stairs (map &mp, int z_after, bool &rope_ladder, bool peeking)
 Returns the other end of the stairs (if any). More...
 
void vertical_shift (int z_after)
 Actual z-level movement part of vertical_move. More...
 
void vertical_notes (int z_before, int z_after)
 Add goes up/down auto_notes (if turned on) More...
 
void use_computer (const tripoint &p)
 Checks to see if a player can use a computer (not illiterate, etc.) and uses if able. More...
 
template<typename T = Creature>
T * critter_by_id (const character_id &id)
 
template<typename T = Creature>
T * critter_at (const tripoint &p, bool allow_hallucination=false)
 Returns the Creature at the given location. More...
 
template<typename T = Creature>
const T * critter_at (const tripoint &p, bool allow_hallucination=false) const
 
template<typename T = Creature>
shared_ptr_fast< T > shared_from (const T &critter)
 Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature). More...
 
size_t num_creatures () const
 Returns the approximate number of creatures in the reality bubble. More...
 
bool update_zombie_pos (const monster &critter, const tripoint &pos)
 Redirects to the creature_tracker update_pos() function. More...
 
void remove_zombie (const monster &critter)
 
void clear_zombies ()
 Redirects to the creature_tracker clear() function. More...
 
bool spawn_hallucination (const tripoint &p)
 Spawns a hallucination at a determined position. More...
 
bool swap_critters (Creature &, Creature &)
 Swaps positions of two creatures. More...
 
Creature_range all_creatures ()
 Returns an anonymous range that contains all creatures. More...
 
monster_range all_monsters ()
 Same as all_creatures but iterators only over monsters. More...
 
npc_range all_npcs ()
 Same as all_creatures but iterators only over npcs. More...
 
std::vector< Creature * > get_creatures_if (const std::function< bool(const Creature &)> &pred)
 Returns all creatures matching a predicate. More...
 
std::vector< npc * > get_npcs_if (const std::function< bool(const npc &)> &pred)
 
Creatureget_creature_if (const std::function< bool(const Creature &)> &pred)
 Returns a creature matching a predicate. More...
 
bool is_empty (const tripoint &p)
 Returns true if there is no player, NPC, or monster on the tile and move_cost > 0. More...
 
bool is_in_sunlight (const tripoint &p)
 Returns true if p is outdoors and it is sunny. More...
 
bool is_sheltered (const tripoint &p)
 Returns true if p is indoors, underground, or in a car. More...
 
bool revive_corpse (const tripoint &p, item &it)
 Revives a corpse at given location. More...
 
void save_cyborg (item *cyborg, const tripoint &couch_pos, player &installer)
 Turns Broken Cyborg monster into Cyborg NPC via surgery. More...
 
bool cancel_activity_query (const std::string &text)
 Asks if the player wants to cancel their activity, and if so cancels it. More...
 
bool cancel_activity_or_ignore_query (distraction_type type, const std::string &text)
 Asks if the player wants to cancel their activity and if so cancels it. More...
 
void moving_vehicle_dismount (const tripoint &dest_loc)
 Handles players exiting from moving vehicles. More...
 
vehicleremoteveh ()
 Returns the current remotely controlled vehicle. More...
 
void setremoteveh (vehicle *veh)
 Sets the current remotely controlled vehicle. More...
 
int assign_mission_id ()
 Returns the next available mission id. More...
 
npcfind_npc (character_id id)
 Find the npc with the given ID. More...
 
void load_npcs ()
 Makes any nearby NPCs on the overmap active. More...
 
void reload_npcs ()
 Unloads, then loads the NPCs. More...
 
const kill_trackerget_kill_tracker () const
 
void add_npc_follower (const character_id &id)
 Add follower id to set of followers. More...
 
void remove_npc_follower (const character_id &id)
 Remove follower id from follower set. More...
 
std::set< character_idget_follower_list ()
 Get set of followers. More...
 
void validate_npc_followers ()
 validate list of followers to account for overmap buffers More...
 
void validate_mounted_npcs ()
 
void validate_linked_vehicles ()
 validate towed vehicles so they get linked up again after a load More...
 
void validate_camps ()
 validate camps to ensure they are on the overmap list More...
 
void autopilot_vehicles ()
 process vehicles that are following the player More...
 
void catch_a_monster (monster *fish, const tripoint &pos, player *p, const time_duration &catch_duration)
 Picks and spawns a random fish from the remaining fish list when a fish is caught. More...
 
std::unordered_set< tripointget_fishable_locations (int distance, const tripoint &fish_pos)
 Get the contiguous fishable locations starting at fish_pos, out to the specificed distance. More...
 
std::vector< monster * > get_fishable_monsters (std::unordered_set< tripoint > &fishable_locations)
 Get the fishable monsters within the provided fishable locations. More...
 
void fling_creature (Creature *c, const units::angle &dir, float flvel, bool controlled=false, bool suppress_map_update=false)
 Flings the input creature in the given direction. More...
 
float natural_light_level (int zlev) const
 
unsigned char light_level (int zlev) const
 Returns coarse number-of-squares of visibility at the current light level. More...
 
void reset_light_level ()
 
character_id assign_npc_id ()
 
Creatureis_hostile_nearby ()
 
Creatureis_hostile_very_close ()
 
point update_map (player &p)
 
point update_map (int &x, int &y)
 
void update_overmap_seen ()
 
void process_artifact (item &it, player &p)
 
void add_artifact_messages (const std::vector< art_effect_passive > &effects)
 
void add_artifact_dreams ()
 
void peek ()
 
void peek (const tripoint &p)
 
cata::optional< tripointlook_debug ()
 
bool check_zone (const zone_type_id &type, const tripoint &where) const
 
bool check_near_zone (const zone_type_id &type, const tripoint &where) const
 Checks whether or not there is a zone of particular type nearby. More...
 
bool is_zones_manager_open () const
 
void zones_manager ()
 
cata::optional< tripointlook_around ()
 
look_around_result look_around (bool show_window, tripoint &center, const tripoint &start_point, bool has_first_point, bool select_zone, bool peeking, bool is_moving_zone=false, const tripoint &end_point=tripoint_zero)
 
void pre_print_all_tile_info (const tripoint &lp, const catacurses::window &w_info, int &line, int last_line, const visibility_variables &cache)
 
void print_all_tile_info (const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line, int last_line, const visibility_variables &cache)
 
void draw_look_around_cursor (const tripoint &lp, const visibility_variables &cache)
 
void extended_description (const tripoint &p)
 Long description of (visible) things at tile. More...
 
void draw_trail_to_square (const tripoint &t, bool bDrawX)
 
int inventory_item_menu (item_location locThisItem, const std::function< int()> &startx=[]() { return 0;}, const std::function< int()> &width=[]() { return 50;}, inventory_item_menu_positon position=RIGHT_OF_INFO)
 
item_location inv_map_splice (item_filter filter, const std::string &title, int radius=0, const std::string &none_message="")
 Custom-filtered menu for inventory and nearby items and those that within specified radius. More...
 
bool has_gametype () const
 
special_game_id gametype () const
 
void toggle_fullscreen ()
 
void toggle_pixel_minimap ()
 
void reload_tileset ()
 
void temp_exit_fullscreen ()
 
void reenter_fullscreen ()
 
void zoom_in ()
 
void zoom_out ()
 
void reset_zoom ()
 
void set_zoom (int level)
 
int get_zoom () const
 
int get_moves_since_last_save () const
 
int get_user_action_counter () const
 
bool take_screenshot (const std::string &file_path) const
 Saves a screenshot of the current viewport, as a PNG file, to the given location. More...
 
bool take_screenshot () const
 Saves a screenshot of the current viewport, as a PNG file. More...
 
int get_levx () const
 The top left corner of the reality bubble (in submaps coordinates). More...
 
int get_levy () const
 
int get_levz () const
 
void load_map (const tripoint &pos_sm)
 Load the main map at given location, see map::load, in global, absolute submap coordinates. More...
 
void load_map (const tripoint_abs_sm &pos_sm)
 
overmapget_cur_om () const
 The overmap which contains the center submap of the reality bubble. More...
 
std::vector< npc * > allies ()
 Get all living player allies. More...
 
void set_driving_view_offset (const point &p)
 
void calc_driving_offset (vehicle *veh=nullptr)
 
void open_gate (const tripoint &p)
 
void knockback (const tripoint &s, const tripoint &t, int force, int stun, int dam_mult)
 
void knockback (std::vector< tripoint > &traj, int stun, int dam_mult)
 
void draw_bullet (const tripoint &t, int i, const std::vector< tripoint > &trajectory, char bullet)
 
void draw_hit_mon (const tripoint &p, const monster &m, bool dead=false)
 
void draw_hit_player (const Character &p, int dam)
 
void draw_line (const tripoint &p, const tripoint &center_point, const std::vector< tripoint > &points, bool noreveal=false)
 
void draw_line (const tripoint &p, const std::vector< tripoint > &points)
 
void draw_weather (const weather_printable &wPrint)
 
void draw_sct ()
 
void draw_zones (const tripoint &start, const tripoint &end, const tripoint &offset)
 
void draw_critter (const Creature &critter, const tripoint &center)
 
void draw_critter_highlighted (const Creature &critter, const tripoint &center)
 
void draw_cursor (const tripoint &p)
 
void draw_highlight (const tripoint &p)
 
void draw_radiation_override (const tripoint &p, int rad)
 
void draw_terrain_override (const tripoint &p, const ter_id &id)
 
void draw_furniture_override (const tripoint &p, const furn_id &id)
 
void draw_graffiti_override (const tripoint &p, bool has)
 
void draw_trap_override (const tripoint &p, const trap_id &id)
 
void draw_field_override (const tripoint &p, const field_type_id &id)
 
void draw_item_override (const tripoint &p, const itype_id &id, const mtype_id &mid, bool hilite)
 
void draw_vpart_override (const tripoint &p, const vpart_id &id, int part_mod, units::angle veh_dir, bool hilite, const point &mount)
 
void draw_below_override (const tripoint &p, bool draw)
 
void draw_monster_override (const tripoint &p, const mtype_id &id, int count, bool more, Creature::Attitude att)
 
bool is_in_viewport (const tripoint &p, int margin=0) const
 
bool check_safe_mode_allowed (bool repeat_safe_mode_warnings=true)
 Check whether movement is allowed according to safe mode settings. More...
 
void set_safe_mode (safe_mode_type mode)
 
void exam_vehicle (vehicle &veh, const point &cp=point_zero)
 open vehicle interaction screen More...
 
bool forced_door_closing (const tripoint &p, const ter_id &door_type, int bash_dmg)
 
bool load (const std::string &world)
 Attempt to load first valid save (if any) in world. More...
 
bool npc_menu (npc &who)
 Returns true if the menu handled stuff and player shouldn't do anything else. More...
 
bool phasing_move (const tripoint &dest, bool via_ramp=false)
 
bool walk_move (const tripoint &dest, bool via_ramp=false)
 
void on_move_effects ()
 
void reload (item_location &loc, bool prompt=false, bool empty=true)
 
void reload_item ()
 
void reload_wielded (bool prompt=false)
 
void reload_weapon (bool try_everything=true)
 
point place_player (const tripoint &dest)
 
void place_player_overmap (const tripoint_abs_omt &om_dest)
 
bool unload (item_location loc)
 
unsigned int get_seed () const
 
void set_npcs_dirty ()
 If invoked, NPCs will be reloaded before next turn. More...
 
void set_critter_died ()
 If invoked, dead will be cleaned this turn. More...
 
void mon_info (const catacurses::window &, int hor_padding=0)
 
void mon_info_update ()
 
void cleanup_dead ()
 
bool is_dangerous_tile (const tripoint &dest_loc) const
 
std::vector< std::string > get_dangerous_tile (const tripoint &dest_loc) const
 
bool prompt_dangerous_tile (const tripoint &dest_loc) const
 
void despawn_monster (monster &critter)
 Despawn a specific monster, it's stored on the overmap. More...
 
void win ()
 Marks the game as won. More...
 
bool disable_robot (const tripoint &p)
 If there is a robot (that can be disabled), query the player and try to disable it. More...
 
void draw_pixel_minimap (const catacurses::window &w)
 
void quicksave ()
 
void disp_NPCs ()
 
void list_missions ()
 
event_busevents ()
 
stats_trackerstats ()
 
memorial_loggermemorial ()
 
spell_eventsspell_events_subscriber ()
 
void display_toggle_overlay (action_id)
 
bool display_overlay_state (action_id)
 
void toggle_debug_hour_timer ()
 
tripoint mouse_edge_scrolling_terrain (input_context &ctxt)
 Used to implement mouse "edge scrolling". More...
 
tripoint mouse_edge_scrolling_overmap (input_context &ctxt)
 This variant is suitable for the overmap. More...
 
void shift_destination_preview (const point &delta)
 
bool slip_down ()
 Checks if player is able to successfully climb to/from some terrain and not slip down. More...
 
monsterplace_critter_at (const mtype_id &id, const tripoint &p)
 Adds critters to the reality bubble, creating them if necessary. More...
 
monsterplace_critter_at (const shared_ptr_fast< monster > &mon, const tripoint &p)
 
monsterplace_critter_around (const mtype_id &id, const tripoint &center, int radius)
 
monsterplace_critter_around (const shared_ptr_fast< monster > &mon, const tripoint &center, int radius, bool forced=false)
 
monsterplace_critter_within (const mtype_id &id, const tripoint_range< tripoint > &range)
 
monsterplace_critter_within (const shared_ptr_fast< monster > &mon, const tripoint_range< tripoint > &range)
 

Public Attributes

mapm
 
avataru
 
scent_mapscent
 
timed_event_managertimed_events
 
pimpl< Creature_trackercritter_tracker
 
pimpl< faction_managerfaction_manager_ptr
 
pimpl< drop_token_providertoken_provider_ptr
 
quit_status uquit
 Used in main.cpp to determine what type of quit is being performed. More...
 
bool new_game = false
 True if the game has just started or loaded, else false. More...
 
const scenarioscen
 
std::vector< monstercoming_to_stairs
 
int monstairz = 0
 
tripoint ter_view_p
 
catacurses::window w_terrain
 
catacurses::window w_overmap
 
catacurses::window w_omlegend
 
catacurses::window w_minimap
 
catacurses::window w_pixel_minimap
 
point driving_view_offset
 
bool debug_pathfinding = false
 
bool debug_submap_grid_overlay = false
 
Creaturedisplaying_visibility_creature
 Creature for which to display the visibility map. More...
 
int displaying_lighting_condition = 0
 Type of lighting condition overlay to display. More...
 
bool show_panel_adm = false
 
bool right_sidebar = false
 
bool fullscreen = false
 
bool was_fullscreen = false
 
bool auto_travel_mode = false
 
bool queue_screenshot = false
 
safe_mode_type safe_mode
 
int turnssincelastmon = 0
 
int mostseen = 0
 

Protected Member Functions

void load_data_from_dir (const std::string &path, const std::string &src, loading_ui &ui)
 Loads dynamic data from the given directory. More...
 

Private Types

enum class  vmenu_ret : int { CHANGE_TAB , QUIT , FIRE }
 

Private Member Functions

void unload_npcs ()
 Unloads all NPCs. More...
 
bool load (const save_t &name)
 
void load_master ()
 
bool start_game ()
 
bool save_factions_missions_npcs ()
 
void reset_npc_dispositions ()
 
void serialize_master (std::ostream &fout)
 
bool save_artifacts ()
 
bool save_maps ()
 
void init_autosave ()
 
void create_starting_npcs ()
 
vehicleplace_vehicle_nearby (const vproto_id &id, const point_abs_omt &origin, int min_distance, int max_distance, const std::vector< std::string > &omt_search_types={})
 
void list_items_monsters ()
 
game::vmenu_ret list_items (const std::vector< map_item_stack > &item_list)
 
std::vector< map_item_stackfind_nearby_items (int iRadius)
 
void reset_item_list_state (const catacurses::window &window, int height, bool bRadiusSort)
 
game::vmenu_ret list_monsters (const std::vector< Creature * > &monster_list)
 
bool grabbed_move (const tripoint &dp)
 Check for dangerous stuff at dest_loc, return false if the player decides not to step there. More...
 
bool grabbed_veh_move (const tripoint &dp)
 
bool grabbed_furn_move (const tripoint &dp)
 
void control_vehicle ()
 
void examine (const tripoint &p)
 
void examine ()
 
void pickup ()
 
void pickup (const tripoint &p)
 
void pickup_feet ()
 
void drop ()
 
void drop_in_direction ()
 
void butcher ()
 
void wield ()
 
void wield (item_location &loc)
 
void chat ()
 
void print_fields_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line)
 
void print_terrain_info (const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line)
 
void print_trap_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line)
 
void print_creature_info (const Creature *creature, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_vehicle_info (const vehicle *veh, int veh_part, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_visibility_info (const catacurses::window &w_look, int column, int &line, visibility_type visibility)
 
void print_items_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
 
void print_graffiti_info (const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
 
input_context get_player_input (std::string &action)
 
void replace_stair_monsters ()
 
void update_stair_monsters ()
 
void shift_monsters (const tripoint &shift)
 Shift all active monsters, the shift vector is the number of shifted submaps. More...
 
void perhaps_add_random_npc ()
 
void monmove ()
 
void overmap_npc_move ()
 
void process_voluntary_act_interrupt ()
 
void process_activity ()
 
void handle_key_blocking_activity ()
 
void open_consume_item_menu ()
 
bool handle_action ()
 
bool try_get_right_click_action (action_id &act, const tripoint &mouse_target)
 
bool try_get_left_click_action (action_id &act, const tripoint &mouse_target)
 
void item_action_menu ()
 
bool is_game_over ()
 
void death_screen ()
 
void win_screen ()
 
void draw_minimap ()
 
void autosave ()
 
void quickload ()
 
bool handle_mouseview (input_context &ctxt, std::string &action)
 
void display_faction_epilogues ()
 
void disp_NPC_epilogues ()
 
void display_scent ()
 
void display_temperature ()
 
void display_vehicle_ai ()
 
void display_visibility ()
 
void display_lighting ()
 
void display_radiation ()
 
void display_transparency ()
 
Creatureis_hostile_within (int distance)
 
void move_save_to_graveyard (const std::string &dirname)
 
bool save_player_data ()
 
std::pair< tripoint, tripointmouse_edge_scrolling (input_context &ctxt, int speed, const tripoint &last, bool iso)
 

Private Attributes

bool is_looking = false
 
std::vector< weak_ptr_fast< draw_callback_t > > draw_callbacks
 
cata::optional< action_iddisplaying_overlays
 
class game::debug_hour_timer debug_hour_timer
 
pimpl< mapmap_ptr
 
pimpl< avataru_ptr
 
pimpl< live_viewliveview_ptr
 
live_viewliveview
 
pimpl< scent_mapscent_ptr
 
pimpl< timed_event_managertimed_event_manager_ptr
 
pimpl< event_busevent_bus_ptr
 
pimpl< stats_trackerstats_tracker_ptr
 
pimpl< achievements_trackerachievements_tracker_ptr
 
pimpl< kill_trackerkill_tracker_ptr
 
pimpl< memorial_loggermemorial_logger_ptr
 
pimpl< spell_eventsspell_events_ptr
 
pimpl< distribution_grid_trackergrid_tracker_ptr
 
pimpl< weather_managerweather_manager_ptr
 
shared_ptr_fast< playeru_shared_ptr
 
catacurses::window w_terrain_ptr
 
catacurses::window w_minimap_ptr
 
std::string sFilter
 
std::string list_item_upvote
 
std::string list_item_downvote
 
bool safe_mode_warning_logged = false
 
bool bVMonsterLookFire = false
 
character_id next_npc_id
 
std::list< shared_ptr_fast< npc > > active_npc
 
int next_mission_id = 0
 
std::set< character_idfollower_ids
 
int moves_since_last_save = 0
 
time_t last_save_timestamp
 
std::array< float, OVERMAP_LAYERSlatest_lightlevels
 
time_point remoteveh_cache_time
 
vehicleremoteveh_cache
 
bool npcs_dirty = false
 Has a NPC been spawned since last load? More...
 
bool critter_died = false
 Has anything died in this turn and needs to be cleaned up? More...
 
bool first_redraw_since_waiting_started = true
 Is this the first redraw since waiting (sleeping or activity) started. More...
 
bool zones_manager_open = false
 Is Zone manager open or not - changes graphics of some zone tiles. More...
 
std::unique_ptr< special_gamegamemode
 
int user_action_counter = 0
 
int tileset_zoom = 0
 How far the tileset should be zoomed out, 16 is default. More...
 
unsigned int seed = 0
 Seed for all the random numbers that should have consistent randomness (weather). More...
 
std::vector< tripointdestination_preview
 
std::chrono::time_point< std::chrono::steady_clock > last_mouse_edge_scroll
 
tripoint last_mouse_edge_scroll_vector_terrain
 
tripoint last_mouse_edge_scroll_vector_overmap
 
weak_ptr_fast< ui_adaptormain_ui_adaptor
 
std::unique_ptr< static_popupwait_popup
 

Friends

class editmap
 
class advanced_inventory
 
class main_menu
 
class monster_range
 
class Creature_range
 
distribution_grid_trackerget_distribution_grid_tracker ()
 Returns distribution grid tracker that is a part of the global game *g. More...
 
mapget_map ()
 
Characterget_player_character ()
 
avatarget_avatar ()
 
weather_managerget_weather ()
 

Detailed Description

Definition at line 143 of file game.h.

Member Enumeration Documentation

◆ inventory_item_menu_positon

Enumerator
RIGHT_TERMINAL_EDGE 
LEFT_OF_INFO 
RIGHT_OF_INFO 
LEFT_TERMINAL_EDGE 

Definition at line 611 of file game.h.

611 {
616 };
@ LEFT_OF_INFO
Definition: game.h:613
@ RIGHT_OF_INFO
Definition: game.h:614
@ RIGHT_TERMINAL_EDGE
Definition: game.h:612
@ LEFT_TERMINAL_EDGE
Definition: game.h:615

◆ vmenu_ret

enum class game::vmenu_ret : int
strongprivate
Enumerator
CHANGE_TAB 
QUIT 
FIRE 

Definition at line 805 of file game.h.

805 : int {
806 CHANGE_TAB,
807 QUIT,
808 FIRE, // Who knew, apparently you can do that in list_monsters
809 };

Constructor & Destructor Documentation

◆ game()

game::game ( )

Definition at line 286 of file game.cpp.

286 :
288 scent_ptr( *this ),
291 m( *map_ptr ),
292 u( *u_ptr ),
293 scent( *scent_ptr ),
295 uquit( QUIT_NO ),
296 new_game( false ),
298 mostseen( 0 ),
301 next_npc_id( 1 ),
302 next_mission_id( 1 ),
306 seed( 0 ),
307 last_mouse_edge_scroll( std::chrono::steady_clock::now() )
308{
316 world_generator = std::make_unique<worldfactory>();
317 // do nothing, everything that was in here is moved to init_data() which is called immediately after g = new game; in main.cpp
318 // The reason for this move is so that g is not uninitialized when it gets to installing the parts into vehicles.
319}
void subscribe(event_subscriber *)
Definition: event_bus.cpp:39
int mostseen
Definition: game.h:1071
pimpl< spell_events > spell_events_ptr
Definition: game.h:1006
safe_mode_type safe_mode
Definition: game.h:1068
bool safe_mode_warning_logged
Definition: game.h:1082
pimpl< timed_event_manager > timed_event_manager_ptr
Definition: game.h:1000
std::chrono::time_point< std::chrono::steady_clock > last_mouse_edge_scroll
Definition: game.h:1116
quit_status uquit
Used in main.cpp to determine what type of quit is being performed.
Definition: game.h:1026
event_bus & events()
Definition: game.cpp:3091
pimpl< stats_tracker > stats_tracker_ptr
Definition: game.h:1002
character_id next_npc_id
Definition: game.h:1084
pimpl< kill_tracker > kill_tracker_ptr
Definition: game.h:1004
void reset_light_level()
Definition: game.cpp:3935
pimpl< memorial_logger > memorial_logger_ptr
Definition: game.h:1005
shared_ptr_fast< player > u_shared_ptr
Definition: game.h:1073
pimpl< map > map_ptr
Definition: game.h:995
bool first_redraw_since_waiting_started
Is this the first redraw since waiting (sleeping or activity) started.
Definition: game.h:1099
pimpl< live_view > liveview_ptr
Definition: game.h:997
pimpl< achievements_tracker > achievements_tracker_ptr
Definition: game.h:1003
pimpl< scent_map > scent_ptr
Definition: game.h:999
timed_event_manager & timed_events
Definition: game.h:1014
unsigned int seed
Seed for all the random numbers that should have consistent randomness (weather).
Definition: game.h:1111
int next_mission_id
Definition: game.h:1086
bool new_game
True if the game has just started or loaded, else false.
Definition: game.h:1028
pimpl< distribution_grid_tracker > grid_tracker_ptr
Definition: game.h:1007
map & m
Definition: game.h:1011
avatar & u
Definition: game.h:1012
scent_map & scent
Definition: game.h:1013
int user_action_counter
Definition: game.h:1105
live_view & liveview
Definition: game.h:998
int tileset_zoom
How far the tileset should be zoomed out, 16 is default.
Definition: game.h:1108
pimpl< avatar > u_ptr
Definition: game.h:996
time_point remoteveh_cache_time
Definition: game.h:1092
static void achievement_attained(const achievement *a)
Definition: game.cpp:279
static constexpr int DEFAULT_TILESET_ZOOM
Definition: game.h:41
@ SAFE_MODE_ON
Definition: game.h:78
@ QUIT_NO
Definition: game.h:68
mapbuffer MAPBUFFER
Definition: mapbuffer.cpp:40
const time_point before_time_starts
A time point that is always before the current turn, even when the game has just started.
Definition: calendar.cpp:25
For use with smart pointers when you don't actually want the deleter to do anything.
Definition: cata_utility.h:28
std::unique_ptr< worldfactory > world_generator

References achievements_tracker_ptr, events(), first_redraw_since_waiting_started, kill_tracker_ptr, memorial_logger_ptr, reset_light_level(), spell_events_ptr, stats_tracker_ptr, event_bus::subscribe(), and world_generator.

◆ ~game()

game::~game ( )
default

Member Function Documentation

◆ add_artifact_dreams()

void game::add_artifact_dreams ( )

Definition at line 12388 of file game.cpp.

12389{
12390 //If player is sleeping, get a dream from a carried artifact
12391 //Don't need to check that player is sleeping here, that's done before calling
12392 std::list<item *> art_items = g->u.get_artifact_items();
12393 std::vector<item *> valid_arts;
12394 std::vector<std::vector<std::string>>
12395 valid_dreams; // Tracking separately so we only need to check its req once
12396 //Pull the list of dreams
12397 add_msg( m_debug, "Checking %s carried artifacts", art_items.size() );
12398 for( auto &it : art_items ) {
12399 //Pick only the ones with an applicable dream
12400 const cata::value_ptr<islot_artifact> &art = it->type->artifact;
12401 if( art && art->charge_req != ACR_NULL &&
12402 ( it->ammo_remaining() < it->ammo_capacity() ||
12403 it->ammo_capacity() == 0 ) ) { //or max 0 in case of wacky mod shenanigans
12404 add_msg( m_debug, "Checking artifact %s", it->tname() );
12405 if( check_art_charge_req( *it ) ) {
12406 add_msg( m_debug, " Has freq %s,%s", art->dream_freq_met, art->dream_freq_unmet );
12407 if( art->dream_freq_met > 0 && x_in_y( art->dream_freq_met, 100 ) ) {
12408 add_msg( m_debug, "Adding met dream from %s", it->tname() );
12409 valid_arts.push_back( it );
12410 valid_dreams.push_back( art->dream_msg_met );
12411 }
12412 } else {
12413 add_msg( m_debug, " Has freq %s,%s", art->dream_freq_met, art->dream_freq_unmet );
12414 if( art->dream_freq_unmet > 0 && x_in_y( art->dream_freq_unmet, 100 ) ) {
12415 add_msg( m_debug, "Adding unmet dream from %s", it->tname() );
12416 valid_arts.push_back( it );
12417 valid_dreams.push_back( art->dream_msg_unmet );
12418 }
12419 }
12420 }
12421 }
12422 if( !valid_dreams.empty() ) {
12423 add_msg( m_debug, "Found %s valid artifact dreams", valid_dreams.size() );
12424 const int selected = rng( 0, valid_arts.size() - 1 );
12425 auto it = valid_arts[selected];
12426 auto msg = random_entry( valid_dreams[selected] );
12427 const std::string &dream = string_format( _( msg ), it->tname() );
12428 add_msg( dream );
12429 } else {
12430 add_msg( m_debug, "Didn't have any dreams, sorry" );
12431 }
12432}
units::quantity< V, B > rng(const units::quantity< V, B > &min, const units::quantity< V, B > &max)
Definition: artifact.cpp:32
@ ACR_NULL
Definition: artifact.h:79
bool x_in_y(const time_duration &a, const time_duration &b)
Definition: calendar.cpp:521
This class is essentially a copyable unique pointer.
Definition: value_ptr.h:19
@ m_debug
Definition: enums.h:264
std::unique_ptr< game > g
Definition: game.cpp:269
bool check_art_charge_req(item &it)
Definition: game.cpp:12091
void add_msg(std::string msg)
Definition: messages.cpp:884
V random_entry(const C &container, D default_value)
Returns a random entry in the container.
Definition: rng.h:88
std::string string_format(std::string format, Args &&...args)
Simple wrapper over string_formatter::parse.
#define _(msg)
Definition: translations.h:116

References _, ACR_NULL, add_msg(), check_art_charge_req(), g, m_debug, random_entry(), rng(), string_format(), and x_in_y().

Referenced by do_turn().

◆ add_artifact_messages()

void game::add_artifact_messages ( const std::vector< art_effect_passive > &  effects)

Definition at line 12210 of file game.cpp.

12211{
12212 int net_str = 0;
12213 int net_dex = 0;
12214 int net_per = 0;
12215 int net_int = 0;
12216 int net_speed = 0;
12217
12218 for( auto &i : effects ) {
12219 switch( i ) {
12220 case AEP_STR_UP:
12221 net_str += 4;
12222 break;
12223 case AEP_DEX_UP:
12224 net_dex += 4;
12225 break;
12226 case AEP_PER_UP:
12227 net_per += 4;
12228 break;
12229 case AEP_INT_UP:
12230 net_int += 4;
12231 break;
12232 case AEP_ALL_UP:
12233 net_str += 2;
12234 net_dex += 2;
12235 net_per += 2;
12236 net_int += 2;
12237 break;
12238 case AEP_STR_DOWN:
12239 net_str -= 3;
12240 break;
12241 case AEP_DEX_DOWN:
12242 net_dex -= 3;
12243 break;
12244 case AEP_PER_DOWN:
12245 net_per -= 3;
12246 break;
12247 case AEP_INT_DOWN:
12248 net_int -= 3;
12249 break;
12250 case AEP_ALL_DOWN:
12251 net_str -= 2;
12252 net_dex -= 2;
12253 net_per -= 2;
12254 net_int -= 2;
12255 break;
12256
12257 case AEP_SPEED_UP:
12258 net_speed += 20;
12259 break;
12260 case AEP_SPEED_DOWN:
12261 net_speed -= 20;
12262 break;
12263
12264 case AEP_PBLUE:
12265 break; // No message
12266
12267 case AEP_SNAKES:
12268 add_msg( m_warning, _( "Your skin feels slithery." ) );
12269 break;
12270
12271 case AEP_INVISIBLE:
12272 add_msg( m_good, _( "You fade into invisibility!" ) );
12273 break;
12274
12275 case AEP_CLAIRVOYANCE:
12277 add_msg( m_good, _( "You can see through walls!" ) );
12278 break;
12279
12281 add_msg( m_good, _( "You can see through everything!" ) );
12282 break;
12283
12284 case AEP_STEALTH:
12285 add_msg( m_good, _( "Your steps stop making noise." ) );
12286 break;
12287
12288 case AEP_GLOW:
12289 add_msg( _( "A glow of light forms around you." ) );
12290 break;
12291
12292 case AEP_PSYSHIELD:
12293 add_msg( m_good, _( "Your mental state feels protected." ) );
12294 break;
12295
12297 add_msg( m_good, _( "You feel insulated." ) );
12298 break;
12299
12300 case AEP_CARRY_MORE:
12301 add_msg( m_good, _( "Your back feels strengthened." ) );
12302 break;
12303
12304 case AEP_FUN:
12305 add_msg( m_good, _( "You feel a pleasant tingle." ) );
12306 break;
12307
12308 case AEP_HUNGER:
12309 add_msg( m_warning, _( "You feel hungry." ) );
12310 break;
12311
12312 case AEP_THIRST:
12313 add_msg( m_warning, _( "You feel thirsty." ) );
12314 break;
12315
12316 case AEP_EVIL:
12317 add_msg( m_warning, _( "You feel an evil presence…" ) );
12318 break;
12319
12320 case AEP_SCHIZO:
12321 add_msg( m_bad, _( "You feel a tickle of insanity." ) );
12322 break;
12323
12324 case AEP_RADIOACTIVE:
12325 add_msg( m_warning, _( "Your skin prickles with radiation." ) );
12326 break;
12327
12328 case AEP_MUTAGENIC:
12329 add_msg( m_bad, _( "You feel your genetic makeup degrading." ) );
12330 break;
12331
12332 case AEP_ATTENTION:
12333 add_msg( m_warning, _( "You feel an otherworldly attention upon you…" ) );
12334 break;
12335
12336 case AEP_FORCE_TELEPORT:
12337 add_msg( m_bad, _( "You feel a force pulling you inwards." ) );
12338 break;
12339
12340 case AEP_MOVEMENT_NOISE:
12341 add_msg( m_warning, _( "You hear a rattling noise coming from inside yourself." ) );
12342 break;
12343
12344 case AEP_BAD_WEATHER:
12345 add_msg( m_warning, _( "You feel storms coming." ) );
12346 break;
12347
12348 case AEP_SICK:
12349 add_msg( m_bad, _( "You feel unwell." ) );
12350 break;
12351
12352 case AEP_SMOKE:
12353 add_msg( m_warning, _( "A cloud of smoke appears." ) );
12354 break;
12355 default:
12356 //Suppress warnings
12357 break;
12358 }
12359 }
12360
12361 std::string stat_info;
12362 if( net_str != 0 ) {
12363 stat_info += string_format( _( "Str %s%d! " ),
12364 ( net_str > 0 ? "+" : "" ), net_str );
12365 }
12366 if( net_dex != 0 ) {
12367 stat_info += string_format( _( "Dex %s%d! " ),
12368 ( net_dex > 0 ? "+" : "" ), net_dex );
12369 }
12370 if( net_int != 0 ) {
12371 stat_info += string_format( _( "Int %s%d! " ),
12372 ( net_int > 0 ? "+" : "" ), net_int );
12373 }
12374 if( net_per != 0 ) {
12375 stat_info += string_format( _( "Per %s%d! " ),
12376 ( net_per > 0 ? "+" : "" ), net_per );
12377 }
12378
12379 if( !stat_info.empty() ) {
12380 add_msg( m_neutral, stat_info );
12381 }
12382
12383 if( net_speed != 0 ) {
12384 add_msg( m_info, _( "Speed %s%d!" ), ( net_speed > 0 ? "+" : "" ), net_speed );
12385 }
12386}
@ m_good
Definition: enums.h:253
@ m_neutral
Definition: enums.h:260
@ m_info
Definition: enums.h:258
@ m_bad
Definition: enums.h:254
@ m_warning
Definition: enums.h:257
@ AEP_GLOW
Definition: enums.h:115
@ AEP_MUTAGENIC
Definition: enums.h:130
@ AEP_ALL_UP
Definition: enums.h:106
@ AEP_INT_UP
Definition: enums.h:105
@ AEP_INT_DOWN
Definition: enums.h:135
@ AEP_PER_UP
Definition: enums.h:104
@ AEP_PSYSHIELD
Definition: enums.h:116
@ AEP_CLAIRVOYANCE_PLUS
Definition: enums.h:142
@ AEP_MOVEMENT_NOISE
Definition: enums.h:139
@ AEP_STEALTH
Definition: enums.h:113
@ AEP_CARRY_MORE
Definition: enums.h:118
@ AEP_THIRST
Definition: enums.h:125
@ AEP_SPEED_UP
Definition: enums.h:107
@ AEP_EVIL
Definition: enums.h:127
@ AEP_ALL_DOWN
Definition: enums.h:136
@ AEP_DEX_UP
Definition: enums.h:103
@ AEP_SCHIZO
Definition: enums.h:128
@ AEP_DEX_DOWN
Definition: enums.h:133
@ AEP_FUN
Definition: enums.h:120
@ AEP_PER_DOWN
Definition: enums.h:134
@ AEP_FORCE_TELEPORT
Definition: enums.h:138
@ AEP_ATTENTION
Definition: enums.h:131
@ AEP_RADIOACTIVE
Definition: enums.h:129
@ AEP_SUPER_CLAIRVOYANCE
Definition: enums.h:112
@ AEP_BAD_WEATHER
Definition: enums.h:140
@ AEP_SICK
Definition: enums.h:141
@ AEP_CLAIRVOYANCE
Definition: enums.h:111
@ AEP_INVISIBLE
Definition: enums.h:110
@ AEP_STR_UP
Definition: enums.h:102
@ AEP_STR_DOWN
Definition: enums.h:132
@ AEP_HUNGER
Definition: enums.h:124
@ AEP_RESIST_ELECTRICITY
Definition: enums.h:117
@ AEP_PBLUE
Definition: enums.h:108
@ AEP_SPEED_DOWN
Definition: enums.h:137
@ AEP_SNAKES
Definition: enums.h:109
@ AEP_SMOKE
Definition: enums.h:126

References _, add_msg(), AEP_ALL_DOWN, AEP_ALL_UP, AEP_ATTENTION, AEP_BAD_WEATHER, AEP_CARRY_MORE, AEP_CLAIRVOYANCE, AEP_CLAIRVOYANCE_PLUS, AEP_DEX_DOWN, AEP_DEX_UP, AEP_EVIL, AEP_FORCE_TELEPORT, AEP_FUN, AEP_GLOW, AEP_HUNGER, AEP_INT_DOWN, AEP_INT_UP, AEP_INVISIBLE, AEP_MOVEMENT_NOISE, AEP_MUTAGENIC, AEP_PBLUE, AEP_PER_DOWN, AEP_PER_UP, AEP_PSYSHIELD, AEP_RADIOACTIVE, AEP_RESIST_ELECTRICITY, AEP_SCHIZO, AEP_SICK, AEP_SMOKE, AEP_SNAKES, AEP_SPEED_DOWN, AEP_SPEED_UP, AEP_STEALTH, AEP_STR_DOWN, AEP_STR_UP, AEP_SUPER_CLAIRVOYANCE, AEP_THIRST, m_bad, m_good, m_info, m_neutral, m_warning, and string_format().

◆ add_draw_callback()

void game::add_draw_callback ( shared_ptr_fast< draw_callback_t cb)

Definition at line 3386 of file game.cpp.

3387{
3388 draw_callbacks.erase(
3389 std::remove_if( draw_callbacks.begin(), draw_callbacks.end(),
3390 []( const weak_ptr_fast<draw_callback_t> &cbw ) {
3391 return cbw.expired();
3392 } ),
3393 draw_callbacks.end()
3394 );
3395 draw_callbacks.emplace_back( cb );
3396 cb->added = true;
3398}
void invalidate_main_ui_adaptor() const
Definition: game.cpp:3351
std::vector< weak_ptr_fast< draw_callback_t > > draw_callbacks
Definition: game.h:251
std::weak_ptr< T > weak_ptr_fast
Definition: memory_fast.h:17

References draw_callbacks, and invalidate_main_ui_adaptor().

Referenced by get_player_input(), list_items(), list_monsters(), look_around(), pickup(), and zones_manager().

◆ add_npc_follower()

void game::add_npc_follower ( const character_id id)

Add follower id to set of followers.

Definition at line 1960 of file game.cpp.

1961{
1962 follower_ids.insert( id );
1963 u.follower_ids.insert( id );
1964}
std::set< character_id > follower_ids
Definition: game.h:1087
std::set< character_id > follower_ids
Definition: player.h:667

References follower_ids, player::follower_ids, and u.

Referenced by validate_npc_followers().

◆ all_creatures()

game::Creature_range game::all_creatures ( )

Returns an anonymous range that contains all creatures.

The range allows iteration via a range-based for loop, e.g. for( Creature &critter : all_creatures() ) { ... }. One shall not store the returned range nor the iterators. One can freely remove and add creatures to the game during the iteration. Added creatures will not be iterated over.

Definition at line 12544 of file game.cpp.

12545{
12546 return Creature_range( *this );
12547}
friend class Creature_range
Definition: game.h:360

References Creature_range.

Referenced by draw_ter(), get_creature_if(), and get_creatures_if().

◆ all_monsters()

game::monster_range game::all_monsters ( )

Same as all_creatures but iterators only over monsters.

Definition at line 12549 of file game.cpp.

12550{
12551 return monster_range( *this );
12552}
friend class monster_range
Definition: game.h:359

References monster_range.

Referenced by cleanup_at_end(), disp_NPCs(), get_fishable_monsters(), monmove(), place_player_overmap(), shift_monsters(), start_game(), validate_mounted_npcs(), and vertical_move().

◆ all_npcs()

game::npc_range game::all_npcs ( )

Same as all_creatures but iterators only over npcs.

Definition at line 12554 of file game.cpp.

12555{
12556 return npc_range( *this );
12557}

Referenced by do_turn(), and get_npcs_if().

◆ allies()

std::vector< npc * > game::allies ( )

Get all living player allies.

Definition at line 12458 of file game.cpp.

12459{
12460 return get_npcs_if( [&]( const npc & guy ) {
12461 if( !guy.is_hallucination() ) {
12462 return guy.is_ally( g->u );
12463 } else {
12464 return false;
12465 }
12466 } );
12467}
std::vector< npc * > get_npcs_if(const std::function< bool(const npc &)> &pred)
Definition: game.cpp:12481
Definition: npc.h:781
bool is_hallucination() const override
Definition: npc.cpp:3257

References get_npcs_if(), and npc::is_hallucination().

◆ assign_mission_id()

int game::assign_mission_id ( )

Returns the next available mission id.

Definition at line 1948 of file game.cpp.

1949{
1950 int ret = next_mission_id;
1952 return ret;
1953}

References next_mission_id, and cata::hash64_detail::ret.

◆ assign_npc_id()

character_id game::assign_npc_id ( )

Definition at line 3943 of file game.cpp.

3944{
3946 ++next_npc_id;
3947 return ret;
3948}

References next_npc_id, and cata::hash64_detail::ret.

Referenced by load(), and start_game().

◆ autopilot_vehicles()

void game::autopilot_vehicles ( )

process vehicles that are following the player

Definition at line 1753 of file game.cpp.

1754{
1755 for( wrapped_vehicle &veh : m.get_vehicles() ) {
1756 vehicle *&v = veh.v;
1757 if( v->is_following ) {
1758 v->drive_to_local_target( m.getabs( u.pos() ), true );
1759 } else if( v->is_patrolling ) {
1760 v->autopilot_patrol();
1761 }
1762 }
1763}
const tripoint & pos() const override
Definition: character.cpp:714
tripoint getabs(const tripoint &p) const
Translates local (to this map) coordinates of a square to global absolute coordinates.
Definition: map.cpp:8215
VehicleList get_vehicles()
Definition: map.cpp:233
A vehicle as a whole with all its components.
Definition: vehicle.h:675
void autopilot_patrol()
Definition: vehicle.cpp:701
bool is_following
Definition: vehicle.h:1983
bool is_patrolling
Definition: vehicle.h:1984
void drive_to_local_target(const tripoint &target, bool follow_protocol)
Definition: vehicle.cpp:816

References vehicle::autopilot_patrol(), vehicle::drive_to_local_target(), map::get_vehicles(), map::getabs(), vehicle::is_following, vehicle::is_patrolling, m, Character::pos(), and u.

Referenced by do_turn().

◆ autosave()

void game::autosave ( )
private

Definition at line 11877 of file game.cpp.

11878{
11879 //Don't autosave if the min-autosave interval has not passed since the last autosave/quicksave.
11880 if( time( nullptr ) < last_save_timestamp + 60 * get_option<int>( "AUTOSAVE_MINUTES" ) ) {
11881 return;
11882 }
11883 quicksave(); //Driving checks are handled by quicksave()
11884}
time_t last_save_timestamp
Definition: game.h:1089
void quicksave()
Definition: game.cpp:11832

References last_save_timestamp, and quicksave().

Referenced by do_turn().

◆ butcher()

void game::butcher ( )
private

Definition at line 8579 of file game.cpp.

8580{
8581 static const std::string salvage_string = "salvage";
8582 if( u.controlling_vehicle ) {
8583 add_msg( m_info, _( "You can't butcher while driving!" ) );
8584 return;
8585 }
8586
8587 const int factor = u.max_quality( quality_id( "BUTCHER" ) );
8588 const int factorD = u.max_quality( quality_id( "CUT_FINE" ) );
8589 const std::string no_knife_msg = _( "You don't have a butchering tool." );
8590 const std::string no_corpse_msg = _( "There are no corpses here to butcher." );
8591
8592 //You can't butcher on sealed terrain- you have to smash/shovel/etc it open first
8593 if( m.has_flag( "SEALED", u.pos() ) ) {
8594 if( m.sees_some_items( u.pos(), u ) ) {
8595 add_msg( m_info, _( "You can't access the items here." ) );
8596 } else if( factor > INT_MIN || factorD > INT_MIN ) {
8597 add_msg( m_info, no_corpse_msg );
8598 } else {
8599 add_msg( m_info, no_knife_msg );
8600 }
8601 return;
8602 }
8603
8604 const item *first_item_without_tools = nullptr;
8605 // Indices of relevant items
8606 std::vector<map_stack::iterator> corpses;
8607 std::vector<map_stack::iterator> disassembles;
8608 std::vector<map_stack::iterator> salvageables;
8609 map_stack items = m.i_at( u.pos() );
8610 const inventory &crafting_inv = u.crafting_inventory();
8611
8612 // TODO: Properly handle different material whitelists
8613 // TODO: Improve quality of this section
8614 auto salvage_filter = []( item it ) {
8615 const auto usable = it.get_usable_item( salvage_string );
8616 return usable != nullptr;
8617 };
8618
8619 std::vector< item * > salvage_tools = u.items_with( salvage_filter );
8620 int salvage_tool_index = INT_MIN;
8621 item *salvage_tool = nullptr;
8622 const salvage_actor *salvage_iuse = nullptr;
8623 if( !salvage_tools.empty() ) {
8624 salvage_tool = salvage_tools.front();
8625 salvage_tool_index = u.get_item_position( salvage_tool );
8626 item *usable = salvage_tool->get_usable_item( salvage_string );
8627 salvage_iuse = dynamic_cast<const salvage_actor *>(
8628 usable->get_use( salvage_string )->get_actor_ptr() );
8629 }
8630
8631 // Reserve capacity for each to hold entire item set if necessary to prevent
8632 // reallocations later on
8633 corpses.reserve( items.size() );
8634 salvageables.reserve( items.size() );
8635 disassembles.reserve( items.size() );
8636
8637 // Split into corpses, disassemble-able, and salvageable items
8638 // It's not much additional work to just generate a corpse list and
8639 // clear it later, but does make the splitting process nicer.
8640 for( map_stack::iterator it = items.begin(); it != items.end(); ++it ) {
8641 if( it->is_corpse() ) {
8642 corpses.push_back( it );
8643 } else {
8644 if( ( salvage_tool_index != INT_MIN ) && salvage_iuse->valid_to_cut_up( *it ) ) {
8645 salvageables.push_back( it );
8646 }
8647 if( u.can_disassemble( *it, crafting_inv ).success() ) {
8648 disassembles.push_back( it );
8649 } else if( !first_item_without_tools ) {
8650 first_item_without_tools = &*it;
8651 }
8652 }
8653 }
8654
8655 // Clear corpses if butcher and dissect factors are INT_MIN
8656 if( factor == INT_MIN && factorD == INT_MIN ) {
8657 corpses.clear();
8658 }
8659
8660 if( corpses.empty() && disassembles.empty() && salvageables.empty() ) {
8661 if( factor > INT_MIN || factorD > INT_MIN ) {
8662 add_msg( m_info, no_corpse_msg );
8663 } else {
8664 add_msg( m_info, no_knife_msg );
8665 }
8666
8667 if( first_item_without_tools ) {
8668 add_msg( m_info, _( "You don't have the necessary tools to disassemble any items here." ) );
8669 // Just for the "You need x to disassemble y" messages
8670 const auto ret = u.can_disassemble( *first_item_without_tools, crafting_inv );
8671 if( !ret.success() ) {
8672 add_msg( m_info, "%s", ret.c_str() );
8673 }
8674 }
8675 return;
8676 }
8677
8678 Creature *hostile_critter = is_hostile_very_close();
8679 if( hostile_critter != nullptr ) {
8680 if( !query_yn( _( "You see %s nearby! Start butchering anyway?" ),
8681 hostile_critter->disp_name() ) ) {
8682 return;
8683 }
8684 }
8685
8686 // Magic indices for special butcher options
8687 enum : int {
8688 MULTISALVAGE = MAX_ITEM_IN_SQUARE + 1,
8689 MULTIBUTCHER,
8690 MULTIDISASSEMBLE_ONE,
8691 MULTIDISASSEMBLE_ALL,
8692 NUM_BUTCHER_ACTIONS
8693 };
8694 // What are we butchering (i.e.. which vector to pick indices from)
8695 enum {
8696 BUTCHER_CORPSE,
8697 BUTCHER_DISASSEMBLE,
8698 BUTCHER_SALVAGE,
8699 BUTCHER_OTHER // For multisalvage etc.
8700 } butcher_select = BUTCHER_CORPSE;
8701 // Index to std::vector of iterators...
8702 int indexer_index = 0;
8703
8704 // Generate the indexed stacks so we can display them nicely
8705 const auto disassembly_stacks = generate_butcher_stack_display( disassembles );
8706 const auto salvage_stacks = generate_butcher_stack_display( salvageables );
8707 // Always ask before cutting up/disassembly, but not before butchery
8708 size_t ret = 0;
8709 if( !corpses.empty() || !disassembles.empty() || !salvageables.empty() ) {
8710 uilist kmenu;
8711 kmenu.text = _( "Choose corpse to butcher / item to disassemble" );
8712
8713 size_t i = 0;
8714 // Add corpses, disassembleables, and salvagables to the UI
8715 add_corpses( kmenu, corpses, i );
8716 add_disassemblables( kmenu, disassembly_stacks, i );
8717 if( salvage_iuse && !salvageables.empty() ) {
8718 add_salvagables( kmenu, salvage_stacks, i, *salvage_iuse );
8719 }
8720
8721 if( corpses.size() > 1 ) {
8722 kmenu.addentry( MULTIBUTCHER, true, 'b', _( "Butcher everything" ) );
8723 }
8724 if( disassembles.size() > 1 ) {
8725 int time_to_disassemble = 0;
8726 int time_to_disassemble_all = 0;
8727 for( const auto &stack : disassembly_stacks ) {
8728 const int time = recipe_dictionary::get_uncraft( stack.first->typeId() ).time;
8729 time_to_disassemble += time;
8730 time_to_disassemble_all += time * stack.second;
8731 }
8732
8733 kmenu.addentry_col( MULTIDISASSEMBLE_ONE, true, 'D', _( "Disassemble everything once" ),
8734 to_string_clipped( time_duration::from_turns( time_to_disassemble / 100 ) ) );
8735 kmenu.addentry_col( MULTIDISASSEMBLE_ALL, true, 'd', _( "Disassemble everything recursively" ),
8736 to_string_clipped( time_duration::from_turns( time_to_disassemble_all / 100 ) ) );
8737 }
8738 if( salvage_iuse && salvageables.size() > 1 ) {
8739 int time_to_salvage = 0;
8740 for( const auto &stack : salvage_stacks ) {
8741 time_to_salvage += salvage_iuse->time_to_cut_up( *stack.first ) * stack.second;
8742 }
8743
8744 kmenu.addentry_col( MULTISALVAGE, true, 'z', _( "Cut up everything" ),
8745 to_string_clipped( time_duration::from_turns( time_to_salvage / 100 ) ) );
8746 }
8747
8748 kmenu.query();
8749
8750 if( kmenu.ret < 0 || kmenu.ret >= NUM_BUTCHER_ACTIONS ) {
8751 return;
8752 }
8753
8754 ret = static_cast<size_t>( kmenu.ret );
8755 if( ret >= MULTISALVAGE && ret < NUM_BUTCHER_ACTIONS ) {
8756 butcher_select = BUTCHER_OTHER;
8757 indexer_index = ret;
8758 } else if( ret < corpses.size() ) {
8759 butcher_select = BUTCHER_CORPSE;
8760 indexer_index = ret;
8761 } else if( ret < corpses.size() + disassembly_stacks.size() ) {
8762 butcher_select = BUTCHER_DISASSEMBLE;
8763 indexer_index = ret - corpses.size();
8764 } else if( ret < corpses.size() + disassembly_stacks.size() + salvage_stacks.size() ) {
8765 butcher_select = BUTCHER_SALVAGE;
8766 indexer_index = ret - corpses.size() - disassembly_stacks.size();
8767 } else {
8768 debugmsg( "Invalid butchery index: %d", ret );
8769 return;
8770 }
8771 }
8772
8773 if( !u.has_morale_to_craft() ) {
8774 if( butcher_select == BUTCHER_CORPSE || indexer_index == MULTIBUTCHER ) {
8775 add_msg( m_info,
8776 _( "You are not in the mood and the prospect of guts and blood on your hands convinces you to turn away." ) );
8777 } else {
8778 add_msg( m_info,
8779 _( "You are not in the mood and the prospect of work stops you before you begin." ) );
8780 }
8781 return;
8782 }
8783 const auto helpers = u.get_crafting_helpers( 3 );
8784 for( const npc *np : helpers ) {
8785 add_msg( m_info, _( "%s helps with this task…" ), np->name );
8786 }
8787 switch( butcher_select ) {
8788 case BUTCHER_OTHER:
8789 switch( indexer_index ) {
8790 case MULTISALVAGE:
8791 u.assign_activity( activity_id( "ACT_LONGSALVAGE" ), 0, salvage_tool_index );
8792 break;
8793 case MULTIBUTCHER:
8794 butcher_submenu( corpses );
8795 for( map_stack::iterator &it : corpses ) {
8796 u.activity.targets.emplace_back( map_cursor( u.pos() ), &*it );
8797 }
8798 break;
8799 case MULTIDISASSEMBLE_ONE:
8800 u.disassemble_all( true );
8801 break;
8802 case MULTIDISASSEMBLE_ALL:
8803 u.disassemble_all( false );
8804 break;
8805 default:
8806 debugmsg( "Invalid butchery type: %d", indexer_index );
8807 return;
8808 }
8809 break;
8810 case BUTCHER_CORPSE: {
8811 butcher_submenu( corpses, indexer_index );
8812 u.activity.targets.emplace_back( map_cursor( u.pos() ), &*corpses[indexer_index] );
8813 }
8814 break;
8815 case BUTCHER_DISASSEMBLE: {
8816 // Pick index of first item in the disassembly stack
8817 item *const target = &*disassembly_stacks[indexer_index].first;
8818 u.disassemble( item_location( map_cursor( u.pos() ), target ), true );
8819 }
8820 break;
8821 case BUTCHER_SALVAGE: {
8822 if( !salvage_iuse || !salvage_tool ) {
8823 debugmsg( "null salve_iuse or salvage_tool" );
8824 } else {
8825 // Pick index of first item in the salvage stack
8826 item *const target = &*salvage_stacks[indexer_index].first;
8827 item_location item_loc( map_cursor( u.pos() ), target );
8828 salvage_iuse->cut_up( u, *salvage_tool, item_loc );
8829 }
8830 }
8831 break;
8832 }
8833}
string_id< activity_type > activity_id
Definition: activity_type.h:15
static std::string to_string_clipped(const int num, const clipped_unit type, const clipped_align align)
Definition: calendar.cpp:228
bool controlling_vehicle
Definition: character.h:227
player_activity activity
Definition: character.h:1524
int get_item_position(const item *it) const
Returns the item position (suitable for i_at or similar) of a specific item.
Definition: character.cpp:2410
bool has_morale_to_craft() const
Definition: crafting.cpp:330
const inventory & crafting_inventory(bool clear_path)
Definition: crafting.cpp:548
void assign_activity(const activity_id &type, int moves=calendar::INDEFINITELY_LONG, int index=-1, int pos=INT_MIN, const std::string &name="")
Legacy activity assignment, does not work for any activites using the new activity_actor class and ma...
Definition: character.cpp:9203
virtual std::string disp_name(bool possessive=false, bool capitalize_first=false) const =0
Creature * is_hostile_very_close()
Definition: game.cpp:3957
A lightweight handle to an item independent of it's location Unlike a raw pointer can be (de-)seriali...
Definition: item_location.h:23
size_t size() const
Definition: item_stack.cpp:10
iterator begin()
Definition: item_stack.cpp:28
iterator end()
Definition: item_stack.cpp:33
Definition: item.h:176
item * get_usable_item(const std::string &use_name)
Checks this item and its contents (recursively) for types that have use_function with type use_name.
Definition: item.cpp:7806
const use_function * get_use(const std::string &use_name) const
Returns the pointer to use_function with name use_name assigned to the type of this item or any of it...
Definition: item.cpp:7780
Definition: map.h:101
bool has_flag(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2288
map_stack i_at(const tripoint &p)
Definition: map.cpp:4069
bool sees_some_items(const tripoint &p, const Creature &who) const
Check if creature can see some items at p.
Definition: map.cpp:4715
std::vector< item_location > targets
void disassemble_all(bool one_pass)
Definition: crafting.cpp:2034
std::vector< npc * > get_crafting_helpers(size_t max=0) const
Returns nearby NPCs ready and willing to help with crafting or some other manual task.
Definition: crafting.cpp:2326
ret_val< bool > can_disassemble(const item &obj, const inventory &inv) const
Check if the player can disassemble an item using the current crafting inventory.
Definition: crafting.cpp:1859
bool disassemble()
Definition: crafting.cpp:1932
static const recipe & get_uncraft(const itype_id &id)
Returns disassembly recipe (or null recipe if no match)
int time
Definition: recipe.h:59
Cuts stuff up into components.
Definition: iuse_actor.h:567
bool valid_to_cut_up(const item &it) const
int cut_up(player &p, item &it, item_location &cut) const
int time_to_cut_up(const item &it) const
static constexpr time_duration from_turns(const T t)
Named constructors to get a duration representing a multiple of the named time units.
Definition: calendar.h:204
uilist: scrolling vertical list menu
Definition: ui.h:187
int ret
Definition: ui.h:412
void addentry_col(int r, bool e, int k, const std::string &str, const std::string &column, const std::string &desc="")
Definition: ui.cpp:952
std::string text
Definition: ui.h:320
void addentry(const std::string &str)
Definition: ui.cpp:932
int max_quality(const quality_id &qual) const
Return maximum tool quality level provided by instance or INT_MIN if not found.
Definition: visitable.cpp:276
std::vector< item * > items_with(const std::function< bool(const item &)> &filter)
Returns all items (including those within a container) matching the filter.
Definition: visitable.cpp:324
#define debugmsg(...)
Debug message of level DL::Error and class DC::DebugMsg, also includes the source file name and line,...
Definition: debug.h:74
static void butcher_submenu(const std::vector< map_stack::iterator > &corpses, int corpse=-1)
Definition: game.cpp:8430
static void add_salvagables(uilist &menu, const std::vector< std::pair< map_stack::iterator, int > > &stacks, size_t &menu_index, const salvage_actor &salvage_iuse)
Definition: game.cpp:8388
static void add_disassemblables(uilist &menu, const std::vector< std::pair< map_stack::iterator, int > > &stacks, size_t &menu_index)
Definition: game.cpp:8409
static std::vector< std::pair< map_stack::iterator, int > > generate_butcher_stack_display(const std::vector< map_stack::iterator > &its)
Definition: game.cpp:8341
static void add_corpses(uilist &menu, const std::vector< map_stack::iterator > &its, size_t &menu_index)
Definition: game.cpp:8376
static constexpr int MAX_ITEM_IN_SQUARE
void query(bool loop=true, int timeout=-1)
Handle input and update display.
Definition: ui.cpp:828
bool query_yn(const std::string &text)
Definition: output.cpp:698
iuse_actor * get_actor_ptr()
Definition: iuse.h:315
string_id< quality > quality_id
Definition: type_id.h:174

References _, Character::activity, add_corpses(), add_disassemblables(), add_msg(), add_salvagables(), uilist::addentry(), uilist::addentry_col(), Character::assign_activity(), item_stack::begin(), butcher_submenu(), player::can_disassemble(), Character::controlling_vehicle, Character::crafting_inventory(), salvage_actor::cut_up(), debugmsg, player::disassemble(), player::disassemble_all(), Creature::disp_name(), item_stack::end(), time_duration::from_turns(), generate_butcher_stack_display(), use_function::get_actor_ptr(), player::get_crafting_helpers(), Character::get_item_position(), recipe_dictionary::get_uncraft(), item::get_usable_item(), item::get_use(), map::has_flag(), Character::has_morale_to_craft(), map::i_at(), is_hostile_very_close(), visitable< T >::items_with(), m, m_info, MAX_ITEM_IN_SQUARE, visitable< T >::max_quality(), Character::pos(), uilist::query(), query_yn(), cata::hash64_detail::ret, uilist::ret, map::sees_some_items(), item_stack::size(), player_activity::targets, uilist::text, recipe::time, salvage_actor::time_to_cut_up(), to_string_clipped(), u, and salvage_actor::valid_to_cut_up().

Referenced by handle_action().

◆ calc_driving_offset()

void game::calc_driving_offset ( vehicle veh = nullptr)

Definition at line 1334 of file game.cpp.

1335{
1336 if( veh == nullptr || !get_option<bool>( "DRIVING_VIEW_OFFSET" ) ) {
1338 return;
1339 }
1340 const int g_light_level = static_cast<int>( light_level( u.posz() ) );
1341 const int light_sight_range = u.sight_range( g_light_level );
1342 int sight = std::max( veh_lumi( *veh ), light_sight_range );
1343
1344 // The maximal offset will leave at least this many tiles
1345 // between the PC and the edge of the main window.
1346 static const int border_range = 2;
1347 point max_offset( ( getmaxx( w_terrain ) + 1 ) / 2 - border_range - 1,
1348 ( getmaxy( w_terrain ) + 1 ) / 2 - border_range - 1 );
1349
1350 // velocity at or below this results in no offset at all
1351 static const float min_offset_vel = 1 * vehicles::vmiph_per_tile;
1352 // velocity at or above this results in maximal offset
1353 static const float max_offset_vel = std::min( max_offset.y, max_offset.x ) *
1355 float velocity = veh->velocity;
1356 rl_vec2d offset = veh->move_vec();
1357 if( !veh->skidding && veh->player_in_control( u ) &&
1358 std::abs( veh->cruise_velocity - veh->velocity ) < 7 * vehicles::vmiph_per_tile ) {
1359 // Use the cruise controlled velocity, but only if
1360 // it is not too different from the actual velocity.
1361 // The actual velocity changes too often (see above slowdown).
1362 // Using it makes would make the offset change far too often.
1363 offset = veh->face_vec();
1364 velocity = veh->cruise_velocity;
1365 }
1366 float rel_offset;
1367 if( std::fabs( velocity ) < min_offset_vel ) {
1368 rel_offset = 0;
1369 } else if( std::fabs( velocity ) > max_offset_vel ) {
1370 rel_offset = ( velocity > 0 ) ? 1 : -1;
1371 } else {
1372 rel_offset = ( velocity - min_offset_vel ) / ( max_offset_vel - min_offset_vel );
1373 }
1374 // Squeeze into the corners, by making the offset vector longer,
1375 // the PC is still in view as long as both offset.x and
1376 // offset.y are <= 1
1377 if( std::fabs( offset.x ) > std::fabs( offset.y ) && std::fabs( offset.x ) > 0.2 ) {
1378 offset.y /= std::fabs( offset.x );
1379 offset.x = ( offset.x > 0 ) ? +1 : -1;
1380 } else if( std::fabs( offset.y ) > 0.2 ) {
1381 offset.x /= std::fabs( offset.y );
1382 offset.y = offset.y > 0 ? +1 : -1;
1383 }
1384 offset.x *= rel_offset;
1385 offset.y *= rel_offset;
1386 offset.x *= max_offset.x;
1387 offset.y *= max_offset.y;
1388 // [ ----@---- ] sight=6
1389 // [ --@------ ] offset=2
1390 // [ -@------# ] offset=3
1391 // can see sights square in every direction, total visible area is
1392 // (2*sight+1)x(2*sight+1), but the window is only
1393 // getmaxx(w_terrain) x getmaxy(w_terrain)
1394 // The area outside of the window is maxoff (sight-getmax/2).
1395 // If that value is <= 0, the whole visible area fits the window.
1396 // don't apply the view offset at all.
1397 // If the offset is > maxoff, only apply at most maxoff, everything
1398 // above leads to invisible area in front of the car.
1399 // It will display (getmax/2+offset) squares in one direction and
1400 // (getmax/2-offset) in the opposite direction (centered on the PC).
1401 const point maxoff( ( sight * 2 + 1 - getmaxx( w_terrain ) ) / 2,
1402 ( sight * 2 + 1 - getmaxy( w_terrain ) ) / 2 );
1403 if( maxoff.x <= 0 ) {
1404 offset.x = 0;
1405 } else if( offset.x > 0 && offset.x > maxoff.x ) {
1406 offset.x = maxoff.x;
1407 } else if( offset.x < 0 && -offset.x > maxoff.x ) {
1408 offset.x = -maxoff.x;
1409 }
1410 if( maxoff.y <= 0 ) {
1411 offset.y = 0;
1412 } else if( offset.y > 0 && offset.y > maxoff.y ) {
1413 offset.y = maxoff.y;
1414 } else if( offset.y < 0 && -offset.y > maxoff.y ) {
1415 offset.y = -maxoff.y;
1416 }
1417
1418 // Turn the offset into a vector that increments the offset toward the desired position
1419 // instead of setting it there instantly, should smooth out jerkiness.
1420 const point offset_difference( -driving_view_offset + point( offset.x, offset.y ) );
1421
1422 const point offset_sign( ( offset_difference.x < 0 ) ? -1 : 1,
1423 ( offset_difference.y < 0 ) ? -1 : 1 );
1424 // Shift the current offset in the direction of the calculated offset by one tile
1425 // per draw event, but snap to calculated offset if we're close enough to avoid jitter.
1426 offset.x = ( std::abs( offset_difference.x ) > 1 ) ?
1427 ( driving_view_offset.x + offset_sign.x ) : offset.x;
1428 offset.y = ( std::abs( offset_difference.y ) > 1 ) ?
1429 ( driving_view_offset.y + offset_sign.y ) : offset.y;
1430
1431 set_driving_view_offset( point( offset.x, offset.y ) );
1432}
int posz() const override
Definition: character.h:787
int sight_range(int light_level) const override
Returns the player's sight range.
Definition: character.cpp:719
point driving_view_offset
Definition: game.h:1045
catacurses::window w_terrain
Definition: game.h:1035
void set_driving_view_offset(const point &p)
Definition: game.cpp:1691
unsigned char light_level(int zlev) const
Returns coarse number-of-squares of visibility at the current light level.
Definition: game.cpp:3929
rl_vec2d move_vec() const
rl_vec2d face_vec() const
bool skidding
Definition: vehicle.h:1999
bool player_in_control(const Character &p) const
Definition: vehicle.cpp:277
int velocity
Definition: vehicle.h:1918
int cruise_velocity
Definition: vehicle.h:1920
static int veh_lumi(vehicle &veh)
Definition: game.cpp:1316
int getmaxx(const window &win)
Definition: ncurses_def.cpp:58
int getmaxy(const window &win)
Definition: ncurses_def.cpp:63
quantity< V, U > fabs(quantity< V, U > q)
Definition: units_def.h:136
constexpr float vmiph_per_tile
Definition: vehicle.h:68
static constexpr point point_zero
Definition: point.h:274
Definition: point.h:35
int y
Definition: point.h:39
int x
Definition: point.h:38
float y
Definition: point_float.h:13
float x
Definition: point_float.h:12

References vehicle::cruise_velocity, driving_view_offset, units::fabs(), vehicle::face_vec(), catacurses::getmaxx(), catacurses::getmaxy(), light_level(), vehicle::move_vec(), vehicle::player_in_control(), point_zero, Character::posz(), set_driving_view_offset(), Character::sight_range(), vehicle::skidding, u, veh_lumi(), vehicle::velocity, vehicles::vmiph_per_tile, w_terrain, point::x, rl_vec2d::x, point::y, and rl_vec2d::y.

Referenced by do_turn().

◆ cancel_activity_or_ignore_query()

bool game::cancel_activity_or_ignore_query ( distraction_type  type,
const std::string &  text 
)

Asks if the player wants to cancel their activity and if so cancels it.

Additionally checks if the player wants to ignore further distractions.

Definition at line 1792 of file game.cpp.

1793{
1795 if( u.has_distant_destination() ) {
1796 if( cancel_auto_move( u, text ) ) {
1797 return true;
1798 } else {
1800 return false;
1801 }
1802 }
1804 return false;
1805 }
1806 const bool force_uc = get_option<bool>( "FORCE_CAPITAL_YN" );
1807 const auto &allow_key = force_uc ? input_context::disallow_lower_case
1809
1810 const auto &action = query_popup()
1811 .context( "CANCEL_ACTIVITY_OR_IGNORE_QUERY" )
1812 .message( force_uc ?
1813 pgettext( "cancel_activity_or_ignore_query",
1814 "<color_light_red>%s %s (Case Sensitive)</color>" ) :
1815 pgettext( "cancel_activity_or_ignore_query",
1816 "<color_light_red>%s %s</color>" ),
1817 text, u.activity.get_stop_phrase() )
1818 .option( "YES", allow_key )
1819 .option( "NO", allow_key )
1820 .option( "IGNORE", allow_key )
1821 .query()
1822 .action;
1823
1824 if( action == "YES" ) {
1826 return true;
1827 }
1828 if( action == "IGNORE" ) {
1830 for( auto &activity : u.backlog ) {
1831 activity.ignore_distraction( type );
1832 }
1833 }
1834
1837
1838 return false;
1839}
void set_destination(const std::vector< tripoint > &route, const player_activity &new_destination_activity=player_activity())
void cancel_activity()
Definition: character.cpp:9246
std::vector< tripoint > & get_auto_move_route()
std::list< player_activity > backlog
Definition: character.h:1525
bool has_distant_destination() const
static const input_event_filter allow_all_keys
Definition: input.h:541
static const input_event_filter disallow_lower_case
Definition: input.h:540
bool is_distraction_ignored(distraction_type type) const
std::string get_stop_phrase() const
void ignore_distraction(distraction_type type)
UI class for displaying messages or querying player input with popups.
Definition: popup.h:39
query_popup & context(const std::string &cat)
Specify the input context.
Definition: popup.cpp:21
query_popup & option(const std::string &opt)
Specify an action as an option.
Definition: popup.cpp:28
result query()
Query until a valid action or an error happens and return the result.
Definition: popup.cpp:348
query_popup & message(const std::string &fmt, Args &&... args)
Specify the query message.
Definition: popup.h:91
@ action
Definition: dialogue.h:36
@ type
Definition: enums.h:75
static bool cancel_auto_move(player &p, const std::string &text)
Definition: game.cpp:1779
void redraw()
Definition: ui_manager.cpp:285
void refresh_display()
Make changes made to the display visible to the user immediately.
std::string action
Definition: popup.h:68
const char * pgettext(const char *context, const char *msgid)

References action, query_popup::result::action, Character::activity, input_context::allow_all_keys, Character::backlog, Character::cancel_activity(), cancel_auto_move(), query_popup::context(), input_context::disallow_lower_case, Character::get_auto_move_route(), player_activity::get_stop_phrase(), Character::has_distant_destination(), player_activity::ignore_distraction(), invalidate_main_ui_adaptor(), player_activity::is_distraction_ignored(), query_popup::message(), query_popup::option(), pgettext(), query_popup::query(), ui_manager::redraw(), refresh_display(), Character::set_destination(), type, and u.

Referenced by mon_info_update(), monmove(), and process_voluntary_act_interrupt().

◆ cancel_activity_query()

bool game::cancel_activity_query ( const std::string &  text)

Asks if the player wants to cancel their activity, and if so cancels it.

Definition at line 1841 of file game.cpp.

1842{
1844 if( u.has_distant_destination() ) {
1845 if( cancel_auto_move( u, text ) ) {
1846 return true;
1847 } else {
1849 return false;
1850 }
1851 }
1852 if( !u.activity ) {
1853 return false;
1854 }
1855 if( query_yn( "%s %s", text, u.activity.get_stop_phrase() ) ) {
1859 return true;
1860 }
1861 return false;
1862}
void clear_destination()
void resume_backlog_activity()
Definition: character.cpp:9278

References Character::activity, Character::cancel_activity(), cancel_auto_move(), Character::clear_destination(), Character::get_auto_move_route(), player_activity::get_stop_phrase(), Character::has_distant_destination(), invalidate_main_ui_adaptor(), query_yn(), Character::resume_backlog_activity(), Character::set_destination(), and u.

Referenced by handle_key_blocking_activity().

◆ catch_a_monster()

void game::catch_a_monster ( monster fish,
const tripoint pos,
player p,
const time_duration catch_duration 
)

Picks and spawns a random fish from the remaining fish list when a fish is caught.

Definition at line 1765 of file game.cpp.

1767{
1768 //spawn the corpse, rotten by a part of the duration
1770 catch_duration ) ) );
1771 if( u.sees( pos ) ) {
1772 u.add_msg_if_player( m_good, _( "You caught a %s." ), fish->type->nname() );
1773 }
1774 //quietly kill the caught
1775 fish->no_corpse_quiet = true;
1776 fish->die( p );
1777}
bool sees(const tripoint &t, bool is_player=false, int range_mod=0) const override
static item make_corpse(const mtype_id &mt=string_id< mtype >::NULL_ID(), time_point turn=calendar::turn, const std::string &name="", int upgrade_time=-1)
Make a corpse of the given monster type.
Definition: item.cpp:506
item & add_item_or_charges(const tripoint &pos, item obj, bool overflow=true)
Adds an item to map tile or stacks charges.
Definition: map.cpp:4214
bool no_corpse_quiet
Definition: monster.h:484
void die(Creature *killer) override
Empty function.
Definition: monster.cpp:2247
const mtype * type
Definition: monster.h:480
void add_msg_if_player(const std::string &msg) const override
Definition: player.cpp:4205
time_point turn
Definition: calendar.cpp:36
mtype_id id
Definition: mtype.h:240
std::string nname(unsigned int quantity=1) const
Definition: mtype.cpp:65

References _, map::add_item_or_charges(), player::add_msg_if_player(), monster::die(), mtype::id, m, m_good, item::make_corpse(), mtype::nname(), monster::no_corpse_quiet, rng(), Character::sees(), calendar::turn, monster::type, and u.

◆ chat()

void game::chat ( )
private

Definition at line 394 of file npctalk.cpp.

395{
396 int volume = g->u.get_shout_volume();
397
398 const std::vector<npc *> available = get_npcs_if( [&]( const npc & guy ) {
399 // TODO: Get rid of the z-level check when z-level vision gets "better"
400 return u.posz() == guy.posz() && u.sees( guy.pos() ) &&
401 rl_dist( u.pos(), guy.pos() ) <= SEEX * 2;
402 } );
403 const int available_count = available.size();
404 const std::vector<npc *> followers = get_npcs_if( [&]( const npc & guy ) {
405 return guy.is_player_ally() && guy.is_following() && guy.can_hear( u.pos(), volume );
406 } );
407 const int follower_count = followers.size();
408 const std::vector<npc *> guards = get_npcs_if( [&]( const npc & guy ) {
409 return guy.mission == NPC_MISSION_GUARD_ALLY &&
410 guy.companion_mission_role_id != "FACTION_CAMP" &&
411 guy.can_hear( u.pos(), volume );
412 } );
413 const int guard_count = guards.size();
414
415 if( g->u.has_trait( trait_PROF_FOODP ) && !( g->u.is_wearing( itype_id( "foodperson_mask" ) ) ||
416 g->u.is_wearing( itype_id( "foodperson_mask_on" ) ) ) ) {
417 g->u.add_msg_if_player( m_warning, _( "You can't speak without your face!" ) );
418 return;
419 }
420 std::vector<vehicle *> animal_vehicles;
421 std::vector<vehicle *> following_vehicles;
422 std::vector<vehicle *> magic_vehicles;
423 std::vector<vehicle *> magic_following_vehicles;
424 for( auto &veh : g->m.get_vehicles() ) {
425 auto &v = veh.v;
426 if( v->has_engine_type( fuel_type_animal, false ) && v->is_owned_by( g->u ) ) {
427 animal_vehicles.push_back( v );
428 if( v->is_following ) {
429 following_vehicles.push_back( v );
430 }
431 }
432 if( v->magic ) {
433 for( const vpart_reference &vp : v->get_all_parts() ) {
434 const vpart_info &vpi = vp.info();
435 if( vpi.has_flag( "MAGIC_FOLLOW" ) ) {
436 magic_vehicles.push_back( v );
437 if( v->is_following ) {
438 magic_following_vehicles.push_back( v );
439 }
440 break;
441 }
442 }
443 }
444 }
445
446 uilist nmenu;
447 nmenu.text = std::string( _( "What do you want to do?" ) );
448
449 if( !available.empty() ) {
450 nmenu.addentry( NPC_CHAT_TALK, true, 't', available_count == 1 ?
451 string_format( _( "Talk to %s" ), available.front()->name ) :
452 _( "Talk to…" )
453 );
454 }
455 nmenu.addentry( NPC_CHAT_YELL, true, 'a', _( "Yell" ) );
456 nmenu.addentry( NPC_CHAT_SENTENCE, true, 'b', _( "Yell a sentence" ) );
457 if( !animal_vehicles.empty() ) {
459 _( "Whistle at your animals pulling vehicles to follow you." ) );
460 }
461 if( !magic_vehicles.empty() ) {
463 _( "Utter a magical command that will order your magical vehicles to follow you." ) );
464 }
465 if( !magic_following_vehicles.empty() ) {
467 _( "Utter a magical command that will order your magical vehicles to stop following you." ) );
468 }
469 if( !following_vehicles.empty() ) {
471 _( "Whistle at your animals pulling vehicles to stop following you." ) );
472 }
473 if( !guards.empty() ) {
474 nmenu.addentry( NPC_CHAT_FOLLOW, true, 'f', guard_count == 1 ?
475 string_format( _( "Tell %s to follow" ), guards.front()->name ) :
476 _( "Tell someone to follow…" )
477 );
478 }
479 if( !followers.empty() ) {
480 nmenu.addentry( NPC_CHAT_GUARD, true, 'g', follower_count == 1 ?
481 string_format( _( "Tell %s to guard" ), followers.front()->name ) :
482 _( "Tell someone to guard…" )
483 );
484 nmenu.addentry( NPC_CHAT_AWAKE, true, 'w', _( "Tell everyone on your team to wake up" ) );
485 nmenu.addentry( NPC_CHAT_MOUNT, true, 'M', _( "Tell everyone on your team to mount up" ) );
486 nmenu.addentry( NPC_CHAT_DISMOUNT, true, 'm', _( "Tell everyone on your team to dismount" ) );
487 nmenu.addentry( NPC_CHAT_DANGER, true, 'D',
488 _( "Tell everyone on your team to prepare for danger" ) );
489 nmenu.addentry( NPC_CHAT_CLEAR_OVERRIDES, true, 'r',
490 _( "Tell everyone on your team to relax (Clear Overrides)" ) );
491 nmenu.addentry( NPC_CHAT_ORDERS, true, 'o', _( "Tell everyone on your team to temporarily…" ) );
492 }
493 std::string message;
494 std::string yell_msg;
495 bool is_order = true;
496 nmenu.query();
497
498 if( nmenu.ret < 0 ) {
499 return;
500 }
501
502 switch( nmenu.ret ) {
503 case NPC_CHAT_TALK: {
504 const int npcselect = npc_select_menu( available, _( "Talk to whom?" ), false );
505 if( npcselect < 0 ) {
506 return;
507 }
508 available[npcselect]->talk_to_u();
509 break;
510 }
511 case NPC_CHAT_YELL:
512 is_order = false;
513 message = _( "loudly." );
514 break;
515 case NPC_CHAT_SENTENCE: {
516 std::string popupdesc = _( "Enter a sentence to yell" );
518 popup.title( _( "Yell a sentence" ) )
519 .width( 64 )
520 .description( popupdesc )
521 .identifier( "sentence" )
522 .max_length( 128 )
523 .query();
524 yell_msg = popup.text();
525 is_order = false;
526 break;
527 }
528 case NPC_CHAT_GUARD: {
529 const int npcselect = npc_select_menu( followers, _( "Who should guard here?" ) );
530 if( npcselect < 0 ) {
531 return;
532 }
533 if( npcselect == follower_count ) {
534 for( npc *them : followers ) {
536 }
537 yell_msg = _( "Everyone guard here!" );
538 } else {
539 talk_function::assign_guard( *followers[npcselect] );
540 yell_msg = string_format( _( "Guard here, %s!" ), followers[npcselect]->name );
541 }
542 break;
543 }
544 case NPC_CHAT_FOLLOW: {
545 const int npcselect = npc_select_menu( guards, _( "Who should follow you?" ) );
546 if( npcselect < 0 ) {
547 return;
548 }
549 if( npcselect == guard_count ) {
550 for( npc *them : guards ) {
552 }
553 yell_msg = _( "Everyone follow me!" );
554 } else {
555 talk_function::stop_guard( *guards[npcselect] );
556 yell_msg = string_format( _( "Follow me, %s!" ), guards[npcselect]->name );
557 }
558 break;
559 }
560 case NPC_CHAT_AWAKE:
561 for( npc *them : followers ) {
562 talk_function::wake_up( *them );
563 }
564 yell_msg = _( "Stay awake!" );
565 break;
566 case NPC_CHAT_MOUNT:
567 for( npc *them : followers ) {
568 if( them->has_effect( effect_riding ) ) {
569 continue;
570 }
572 }
573 yell_msg = _( "Mount up!" );
574 break;
576 for( npc *them : followers ) {
577 if( them->has_effect( effect_riding ) ) {
578 them->npc_dismount();
579 }
580 }
581 yell_msg = _( "Dismount!" );
582 break;
583 case NPC_CHAT_DANGER:
584 for( npc *them : followers ) {
585 them->rules.set_danger_overrides();
586 }
587 yell_msg = _( "We're in danger. Stay awake, stay close, don't go wandering off, "
588 "and don't open any doors." );
589 break;
591 for( npc *p : followers ) {
593 }
594 yell_msg = _( "As you were." );
595 break;
596 case NPC_CHAT_ORDERS:
597 npc_temp_orders_menu( followers );
598 break;
601 break;
604 break;
607 break;
610 break;
611 default:
612 return;
613 }
614
615 if( !yell_msg.empty() ) {
616 message = string_format( "\"%s\"", yell_msg );
617 }
618 if( !message.empty() ) {
619 add_msg( _( "You yell %s" ), message );
620 u.shout( string_format( _( "%s yelling %s" ), u.disp_name(), message ), is_order );
621 }
622
623 u.moves -= 100;
624}
std::string disp_name(bool possessive=false, bool capitalize_first=false) const override
Returns either "you" or the player's name.
Definition: character.cpp:546
void shout(std::string msg="", bool order=false)
Definition: character.cpp:7743
bool can_hear(const tripoint &source, int volume) const
int moves
Definition: creature.h:569
std::string companion_mission_role_id
Definition: npc.h:1318
npc_mission mission
Definition: npc.h:1325
bool is_player_ally() const
Definition: npc.cpp:1984
bool is_following() const
Definition: npc.cpp:2015
Shows a window querying the user for input.
bool has_flag(const std::string &flag) const
Definition: veh_type.h:336
This is a wrapper over a vehicle pointer and a reference to a part of it.
int rl_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:519
static constexpr int SEEX
std::string message
Definition: mapgen.cpp:403
std::string name(type dir)
Get Human readable name of a direction.
Definition: overmap.cpp:4118
void wake_up(npc &)
void find_mount(npc &)
void clear_overrides(npc &p)
void stop_guard(npc &)
void assign_guard(npc &)
quantity< int, volume_in_milliliter_tag > volume
Definition: units_volume.h:16
@ NPC_MISSION_GUARD_ALLY
Definition: npc.h:187
static const efftype_id effect_riding("riding")
static const trait_id trait_PROF_FOODP("PROF_FOODP")
static int npc_select_menu(const std::vector< npc * > &npc_list, const std::string &prompt, const bool everyone=true)
Definition: npctalk.cpp:220
static void tell_magic_veh_stop_following()
Definition: npctalk.cpp:377
static void tell_veh_stop_following()
Definition: npctalk.cpp:340
static void assign_veh_to_follow()
Definition: npctalk.cpp:351
static void npc_temp_orders_menu(const std::vector< npc * > &npc_list)
Definition: npctalk.cpp:252
static const itype_id fuel_type_animal("animal")
@ NPC_CHAT_MOUNT
Definition: npctalk.cpp:200
@ NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW
Definition: npctalk.cpp:214
@ NPC_CHAT_YELL
Definition: npctalk.cpp:195
@ NPC_CHAT_FOLLOW
Definition: npctalk.cpp:198
@ NPC_CHAT_GUARD
Definition: npctalk.cpp:197
@ NPC_CHAT_DISMOUNT
Definition: npctalk.cpp:201
@ NPC_CHAT_ANIMAL_VEHICLE_FOLLOW
Definition: npctalk.cpp:211
@ NPC_CHAT_ORDERS
Definition: npctalk.cpp:203
@ NPC_CHAT_SENTENCE
Definition: npctalk.cpp:196
@ NPC_CHAT_CLEAR_OVERRIDES
Definition: npctalk.cpp:210
@ NPC_CHAT_DANGER
Definition: npctalk.cpp:202
@ NPC_CHAT_AWAKE
Definition: npctalk.cpp:199
@ NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW
Definition: npctalk.cpp:212
@ NPC_CHAT_TALK
Definition: npctalk.cpp:194
@ NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW
Definition: npctalk.cpp:213
static void tell_magic_veh_to_follow()
Definition: npctalk.cpp:361
int popup(const std::string &text, PopupFlags flags)
Definition: output.cpp:764

References _, add_msg(), uilist::addentry(), talk_function::assign_guard(), assign_veh_to_follow(), available, Character::can_hear(), talk_function::clear_overrides(), npc::companion_mission_role_id, Character::disp_name(), effect_riding, talk_function::find_mount(), fuel_type_animal, g, get_npcs_if(), vpart_info::has_flag(), npc::is_following(), npc::is_player_ally(), m_warning, mapgen_defer::message, npc::mission, Creature::moves, om_direction::name(), NPC_CHAT_ANIMAL_VEHICLE_FOLLOW, NPC_CHAT_ANIMAL_VEHICLE_STOP_FOLLOW, NPC_CHAT_AWAKE, NPC_CHAT_CLEAR_OVERRIDES, NPC_CHAT_COMMAND_MAGIC_VEHICLE_FOLLOW, NPC_CHAT_COMMAND_MAGIC_VEHICLE_STOP_FOLLOW, NPC_CHAT_DANGER, NPC_CHAT_DISMOUNT, NPC_CHAT_FOLLOW, NPC_CHAT_GUARD, NPC_CHAT_MOUNT, NPC_CHAT_ORDERS, NPC_CHAT_SENTENCE, NPC_CHAT_TALK, NPC_CHAT_YELL, NPC_MISSION_GUARD_ALLY, npc_select_menu(), npc_temp_orders_menu(), popup(), Character::pos(), Character::posz(), uilist::query(), uilist::ret, rl_dist(), Character::sees(), SEEX, Character::shout(), talk_function::stop_guard(), string_format(), tell_magic_veh_stop_following(), tell_magic_veh_to_follow(), tell_veh_stop_following(), uilist::text, trait_PROF_FOODP, u, and talk_function::wake_up().

Referenced by handle_action().

◆ check_mod_data()

bool game::check_mod_data ( const std::vector< mod_id > &  opts,
loading_ui ui 
)

Check if mods can be successfully loaded.

Parameters
optscheck specific mods (or all if unspecified)
Returns
whether all mods were successfully loaded

Definition at line 345 of file game.cpp.

346{
347 auto &tree = world_generator->get_mod_manager().get_tree();
348
349 // deduplicated list of mods to check
350 std::set<mod_id> check( opts.begin(), opts.end() );
351
352 // if no specific mods specified check all non-obsolete mods
353 if( check.empty() ) {
354 for( const mod_id &e : world_generator->get_mod_manager().all_mods() ) {
355 if( !e->obsolete ) {
356 check.emplace( e );
357 }
358 }
359 }
360
361 if( check.empty() ) {
362 world_generator->set_active_world( nullptr );
363 world_generator->init();
364 const std::vector<mod_id> mods_empty;
365 WORLDPTR test_world = world_generator->make_new_world( mods_empty );
366 world_generator->set_active_world( test_world );
367
368 // if no loadable mods then test core data only
369 try {
372 } catch( const std::exception &err ) {
373 std::cerr << "Error loading data from json: " << err.what() << std::endl;
374 }
375
376 std::string world_name = world_generator->active_world->world_name;
377 world_generator->delete_world( world_name, true );
378
381 }
382
383 for( const auto &e : check ) {
384 world_generator->set_active_world( nullptr );
385 world_generator->init();
386 const std::vector<mod_id> mods_empty;
387 WORLDPTR test_world = world_generator->make_new_world( mods_empty );
388 if( !test_world ) {
389 std::cerr << "Failed to generate test world." << std::endl;
390 return false;
391 }
392 world_generator->set_active_world( test_world );
393
394 if( !e.is_valid() ) {
395 std::cerr << "Unknown mod: " << e.str() << std::endl;
396 return false;
397 }
398
399 const MOD_INFORMATION &mod = *e;
400
401 if( !tree.is_available( mod.ident ) ) {
402 std::cerr << "Missing dependencies: " << mod.name() << "\n"
403 << tree.get_node( mod.ident )->s_errors() << std::endl;
404 return false;
405 }
406
407 std::cout << "Checking mod " << mod.name() << " [" << mod.ident.str() << "]" << std::endl;
408
409 try {
411
412 // Load any dependencies
413 for( auto &dep : tree.get_dependencies_of_X_as_strings( mod.ident ) ) {
414 load_data_from_dir( dep->path, dep->ident.str(), ui );
415 }
416
417 // Load mod itself
418 load_data_from_dir( mod.path, mod.ident.str(), ui );
420 } catch( const std::exception &err ) {
421 std::cerr << "Error loading data: " << err.what() << std::endl;
422 }
423
424 std::string world_name = world_generator->active_world->world_name;
425 world_generator->delete_world( world_name, true );
426
429 }
430 return true;
431}
void finalize_loaded_data(loading_ui &ui)
Called to finalize the loaded data.
Definition: init.cpp:627
static DynamicDataLoader & get_instance()
Returns the single instance of this class.
Definition: init.cpp:112
void load_data_from_dir(const std::string &path, const std::string &src, loading_ui &ui)
Loads dynamic data from the given directory.
Definition: game.cpp:447
void load_core_data(loading_ui &ui)
Loads core dynamic data.
Definition: game.cpp:438
void reset()
Delete all buffered submaps.
Definition: mapbuffer.cpp:49
int check(unformattable)
Definition: fmtlib_core.h:1610
Definition: overmap_ui.h:17
overmapbuffer overmap_buffer

References detail::check(), overmapbuffer::clear(), DynamicDataLoader::finalize_loaded_data(), DynamicDataLoader::get_instance(), load_core_data(), load_data_from_dir(), MAPBUFFER, overmap_buffer, mapbuffer::reset(), and world_generator.

◆ check_near_zone()

bool game::check_near_zone ( const zone_type_id type,
const tripoint where 
) const

Checks whether or not there is a zone of particular type nearby.

Definition at line 6310 of file game.cpp.

6311{
6312 return zone_manager::get_manager().has_near( type, m.getabs( where ) );
6313}
static zone_manager & get_manager()
Definition: clzones.cpp:125
bool has_near(const zone_type_id &type, const tripoint &where, int range=MAX_DISTANCE, const faction_id &fac=your_fac) const
Definition: clzones.cpp:702

References zone_manager::get_manager(), map::getabs(), zone_manager::has_near(), m, and type.

◆ check_safe_mode_allowed()

bool game::check_safe_mode_allowed ( bool  repeat_safe_mode_warnings = true)

Check whether movement is allowed according to safe mode settings.

Returns
true if the movement is allowed, otherwise false.

Definition at line 9130 of file game.cpp.

9131{
9132 if( !repeat_safe_mode_warnings && safe_mode_warning_logged ) {
9133 // Already warned player since safe_mode_warning_logged is set.
9134 return false;
9135 }
9136
9137 std::string msg_ignore = press_x( ACTION_IGNORE_ENEMY );
9138 if( !msg_ignore.empty() ) {
9139 std::wstring msg_ignore_wide = utf8_to_wstr( msg_ignore );
9140 // Operate on a wide-char basis to prevent corrupted multi-byte string
9141 msg_ignore_wide[0] = towlower( msg_ignore_wide[0] );
9142 msg_ignore = wstr_to_utf8( msg_ignore_wide );
9143 }
9144
9146 // Automatic and mandatory safemode. Make BLOODY sure the player notices!
9147 if( u.get_int_base() < 5 || u.has_trait( trait_id( "PROF_CHURL" ) ) ) {
9149 _( "There's an angry red dot on your body, %s to brush it off." ), msg_ignore );
9150 } else {
9152 _( "You are being laser-targeted, %s to ignore." ), msg_ignore );
9153 }
9155 return false;
9156 }
9157 if( safe_mode != SAFE_MODE_STOP ) {
9158 return true;
9159 }
9160 // Currently driving around, ignore the monster, they have no chance against a proper car anyway (-:
9161 if( u.controlling_vehicle && !get_option<bool>( "SAFEMODEVEH" ) ) {
9162 return true;
9163 }
9164 // Monsters around and we don't want to run
9165 std::string spotted_creature_name;
9166 const monster_visible_info &mon_visible = u.get_mon_visible();
9167 const auto &new_seen_mon = mon_visible.new_seen_mon;
9168
9169 if( new_seen_mon.empty() ) {
9170 // naming consistent with code in game::mon_info
9171 spotted_creature_name = _( "a survivor" );
9173 } else {
9174 spotted_creature_name = new_seen_mon.back()->name();
9175 get_safemode().lastmon_whitelist = spotted_creature_name;
9176 }
9177
9178 std::string whitelist;
9179 if( !get_safemode().empty() ) {
9180 whitelist = string_format( _( " or %s to whitelist the monster" ),
9182 }
9183
9184 const std::string msg_safe_mode = press_x( ACTION_TOGGLE_SAFEMODE );
9186 _( "Spotted %1$s--safe mode is on! (%2$s to turn it off, %3$s to ignore monster%4$s)" ),
9187 spotted_creature_name, msg_safe_mode, msg_ignore, whitelist );
9189 return false;
9190}
std::string press_x(action_id act)
Definition: action.cpp:451
@ ACTION_IGNORE_ENEMY
Ignore the enemy that triggered safemode.
Definition: action.h:221
@ ACTION_WHITELIST_ENEMY
Whitelist the enemy that triggered safemode.
Definition: action.h:223
@ ACTION_TOGGLE_SAFEMODE
Turn safemode on/off, while leaving autosafemode intact.
Definition: action.h:215
std::wstring utf8_to_wstr(const std::string &str)
std::string wstr_to_utf8(const std::wstring &wstr)
bool has_trait(const trait_id &b) const override
Returns true if the player has the entered trait.
Definition: mutation.cpp:103
bool has_effect(const efftype_id &eff_id, body_part bp=num_bp) const
Check if creature has the matching effect.
Definition: creature.cpp:1179
int get_int_base() const override
Definition: avatar.cpp:1009
monster_visible_info & get_mon_visible()
Definition: avatar.h:213
std::string lastmon_whitelist
Definition: safemode_ui.h:87
std::string npc_type_name()
Definition: safemode_ui.cpp:44
@ gmf_bypass_cooldown
Definition: enums.h:281
static const efftype_id effect_laserlocked("laserlocked")
@ SAFE_MODE_STOP
Definition: game.h:79
safemode & get_safemode()
Definition: safemode_ui.cpp:33
Structure allowing a combination of game_message_type and game_message_flags.
Definition: enums.h:286
std::vector< shared_ptr_fast< monster > > new_seen_mon
Definition: avatar.h:40

References _, ACTION_IGNORE_ENEMY, ACTION_TOGGLE_SAFEMODE, ACTION_WHITELIST_ENEMY, add_msg(), Character::controlling_vehicle, effect_laserlocked, avatar::get_int_base(), avatar::get_mon_visible(), get_safemode(), gmf_bypass_cooldown, Creature::has_effect(), Character::has_trait(), safemode::lastmon_whitelist, m_warning, monster_visible_info::new_seen_mon, safemode::npc_type_name(), press_x(), safe_mode, SAFE_MODE_STOP, safe_mode_warning_logged, string_format(), u, utf8_to_wstr(), and wstr_to_utf8().

Referenced by handle_action().

◆ check_zone()

bool game::check_zone ( const zone_type_id type,
const tripoint where 
) const

Definition at line 6305 of file game.cpp.

6306{
6307 return zone_manager::get_manager().has( type, m.getabs( where ) );
6308}
bool has(const zone_type_id &type, const tripoint &where, const faction_id &fac=your_fac) const
Definition: clzones.cpp:694

References zone_manager::get_manager(), map::getabs(), zone_manager::has(), m, and type.

Referenced by place_player().

◆ cleanup_at_end()

bool game::cleanup_at_end ( )

Definition at line 1030 of file game.cpp.

1031{
1032 if( uquit == QUIT_DIED || uquit == QUIT_SUICIDE ) {
1033 // Put (non-hallucinations) into the overmap so they are not lost.
1034 for( monster &critter : all_monsters() ) {
1035 despawn_monster( critter );
1036 }
1037 // Reset NPC factions and disposition
1039 // Save the factions', missions and set the NPC's overmap coordinates
1040 // Npcs are saved in the overmap.
1041 save_factions_missions_npcs(); //missions need to be saved as they are global for all saves.
1042 // save artifacts.
1044
1045 // and the overmap, and the local map.
1046 save_maps(); //Omap also contains the npcs who need to be saved.
1047 }
1048
1049 if( uquit == QUIT_DIED || uquit == QUIT_SUICIDE ) {
1050 std::vector<std::string> vRip;
1051
1052 int iMaxWidth = 0;
1053 int iNameLine = 0;
1054 int iInfoLine = 0;
1055
1058 if( !( u.has_trait( trait_id( "CANNIBAL" ) ) || u.has_trait( trait_id( "PSYCHOPATH" ) ) ) ) {
1059 vRip.emplace_back( " _______ ___" );
1060 vRip.emplace_back( " < `/ |" );
1061 vRip.emplace_back( " > _ _ (" );
1062 vRip.emplace_back( " | |_) | |_) |" );
1063 vRip.emplace_back( " | | \\ | | |" );
1064 vRip.emplace_back( " ______.__%_| |_________ __" );
1065 vRip.emplace_back( " _/ \\| |" );
1066 iNameLine = vRip.size();
1067 vRip.emplace_back( "| <" );
1068 vRip.emplace_back( "| |" );
1069 iMaxWidth = utf8_width( vRip.back() );
1070 vRip.emplace_back( "| |" );
1071 vRip.emplace_back( "|_____.-._____ __/|_________|" );
1072 vRip.emplace_back( " | |" );
1073 iInfoLine = vRip.size();
1074 vRip.emplace_back( " | |" );
1075 vRip.emplace_back( " | <" );
1076 vRip.emplace_back( " | |" );
1077 vRip.emplace_back( " | _ |" );
1078 vRip.emplace_back( " |__/ |" );
1079 vRip.emplace_back( " % / `--. |%" );
1080 vRip.emplace_back( " * .%%| -< @%%%" ); // NOLINT(cata-text-style)
1081 vRip.emplace_back( " `\\%`@| |@@%@%%" );
1082 vRip.emplace_back( " .%%%@@@|% ` % @@@%%@%%%%" );
1083 vRip.emplace_back( " _.%%%%%%@@@@@@%%%__/\\%@@%%@@@@@@@%%%%%%" );
1084
1085 } else {
1086 vRip.emplace_back( " _______ ___" );
1087 vRip.emplace_back( " | \\/ |" );
1088 vRip.emplace_back( " | |" );
1089 vRip.emplace_back( " | |" );
1090 iInfoLine = vRip.size();
1091 vRip.emplace_back( " | |" );
1092 vRip.emplace_back( " | |" );
1093 vRip.emplace_back( " | |" );
1094 vRip.emplace_back( " | |" );
1095 vRip.emplace_back( " | <" );
1096 vRip.emplace_back( " | _ |" );
1097 vRip.emplace_back( " |__/ |" );
1098 vRip.emplace_back( " ______.__%_| |__________ _" );
1099 vRip.emplace_back( " _/ \\| \\" );
1100 iNameLine = vRip.size();
1101 vRip.emplace_back( "| <" );
1102 vRip.emplace_back( "| |" );
1103 iMaxWidth = utf8_width( vRip.back() );
1104 vRip.emplace_back( "| |" );
1105 vRip.emplace_back( "|_____.-._______ __/|__________|" );
1106 vRip.emplace_back( " % / `_-. _ |%" );
1107 vRip.emplace_back( " * .%%| |_) | |_)< @%%%" ); // NOLINT(cata-text-style)
1108 vRip.emplace_back( " `\\%`@| | \\ | | |@@%@%%" );
1109 vRip.emplace_back( " .%%%@@@|% ` % @@@%%@%%%%" );
1110 vRip.emplace_back( " _.%%%%%%@@@@@@%%%__/\\%@@%%@@@@@@@%%%%%%" );
1111 }
1112 } else {
1113 vRip.emplace_back( R"( _________ ____ )" );
1114 vRip.emplace_back( R"( _/ `/ \_ )" );
1115 vRip.emplace_back( R"( _/ _ _ \_. )" );
1116 vRip.emplace_back( R"( _%\ |_) | |_) \_ )" );
1117 vRip.emplace_back( R"( _/ \/ | \ | | \_ )" );
1118 vRip.emplace_back( R"( _/ \_ )" );
1119 vRip.emplace_back( R"(| |)" );
1120 iNameLine = vRip.size();
1121 vRip.emplace_back( R"( ) < )" );
1122 vRip.emplace_back( R"(| |)" );
1123 vRip.emplace_back( R"(| |)" );
1124 vRip.emplace_back( R"(| _ |)" );
1125 vRip.emplace_back( R"(|__/ |)" );
1126 iMaxWidth = utf8_width( vRip.back() );
1127 vRip.emplace_back( R"( / `--. |)" );
1128 vRip.emplace_back( R"(| ( )" );
1129 iInfoLine = vRip.size();
1130 vRip.emplace_back( R"(| |)" );
1131 vRip.emplace_back( R"(| |)" );
1132 vRip.emplace_back( R"(| % . |)" );
1133 vRip.emplace_back( R"(| @` %% |)" );
1134 vRip.emplace_back( R"(| %@%@%\ * %`%@%|)" );
1135 vRip.emplace_back( R"(%%@@@.%@%\%% `\ %%.%%@@%@)" );
1136 vRip.emplace_back( R"(@%@@%%%%%@@@@@@%%%%%%%%@@%%@@@%%%@%%@)" );
1137 }
1138
1139 const int iOffsetX = TERMX > FULL_SCREEN_WIDTH ? ( TERMX - FULL_SCREEN_WIDTH ) / 2 : 0;
1140 const int iOffsetY = TERMY > FULL_SCREEN_HEIGHT ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0;
1141
1143 point( iOffsetX, iOffsetY ) );
1144 draw_border( w_rip );
1145
1146 sfx::do_player_death_hurt( g->u, true );
1151
1152 for( size_t iY = 0; iY < vRip.size(); ++iY ) {
1153 size_t iX = 0;
1154 const char *str = vRip[iY].data();
1155 for( int slen = vRip[iY].size(); slen > 0; ) {
1156 const uint32_t cTemp = UTF8_getch( &str, &slen );
1157 if( cTemp != U' ' ) {
1158 nc_color ncColor = c_light_gray;
1159
1160 if( cTemp == U'%' ) {
1161 ncColor = c_green;
1162
1163 } else if( cTemp == U'_' || cTemp == U'|' ) {
1164 ncColor = c_white;
1165
1166 } else if( cTemp == U'@' ) {
1167 ncColor = c_brown;
1168
1169 } else if( cTemp == U'*' ) {
1170 ncColor = c_red;
1171 }
1172
1173 mvwputch( w_rip, point( iX + FULL_SCREEN_WIDTH / 2 - ( iMaxWidth / 2 ), iY + 1 ), ncColor,
1174 cTemp );
1175 }
1176 iX += mk_wcwidth( cTemp );
1177 }
1178 }
1179
1180 std::string sTemp;
1181
1182 center_print( w_rip, iInfoLine++, c_white, _( "Survived:" ) );
1183
1185 const int minutes = to_minutes<int>( survived ) % 60;
1186 const int hours = to_hours<int>( survived ) % 24;
1187 const int days = to_days<int>( survived );
1188
1189 if( days > 0 ) {
1190 sTemp = string_format( "%dd %dh %dm", days, hours, minutes );
1191 } else if( hours > 0 ) {
1192 sTemp = string_format( "%dh %dm", hours, minutes );
1193 } else {
1194 sTemp = string_format( "%dm", minutes );
1195 }
1196
1197 center_print( w_rip, iInfoLine++, c_white, sTemp );
1198
1199 const int iTotalKills = get_kill_tracker().monster_kill_count();
1200
1201 sTemp = _( "Kills:" );
1202 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - 5, 1 + iInfoLine++ ), c_light_gray,
1203 ( sTemp + " " ) );
1204 wprintz( w_rip, c_magenta, "%d", iTotalKills );
1205
1206 sTemp = _( "In memory of:" );
1207 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ),
1209 sTemp );
1210
1211 sTemp = u.name;
1212 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ), c_white,
1213 sTemp );
1214
1215 sTemp = _( "Last Words:" );
1216 mvwprintz( w_rip, point( FULL_SCREEN_WIDTH / 2 - utf8_width( sTemp ) / 2, iNameLine++ ),
1218 sTemp );
1219
1220 int iStartX = FULL_SCREEN_WIDTH / 2 - ( ( iMaxWidth - 4 ) / 2 );
1221 std::string sLastWords = string_input_popup()
1222 .window( w_rip, point( iStartX, iNameLine ), iStartX + iMaxWidth - 4 - 1 )
1223 .max_length( iMaxWidth - 4 - 1 )
1224 .query_string();
1225 death_screen();
1226 const bool is_suicide = uquit == QUIT_SUICIDE;
1227 events().send<event_type::game_over>( is_suicide, sLastWords );
1228 // Struck the save_player_data here to forestall Weirdness
1229 std::string char_filename = generate_memorial_filename( u.name );
1230 move_save_to_graveyard( char_filename );
1231 write_memorial_file( char_filename, sLastWords );
1232 memorial().clear();
1233 std::vector<std::string> characters = list_active_characters();
1234 // remove current player from the active characters list, as they are dead
1235 std::vector<std::string>::iterator curchar = std::find( characters.begin(),
1236 characters.end(), u.name );
1237 if( curchar != characters.end() ) {
1238 characters.erase( curchar );
1239 }
1240
1241 if( characters.empty() ) {
1242 bool queryDelete = false;
1243 bool queryReset = false;
1244
1245 if( get_option<std::string>( "WORLD_END" ) == "query" ) {
1246 bool decided = false;
1247 std::string buffer = _( "Warning: NPC interactions and some other global flags "
1248 "will not all reset when starting a new character in an "
1249 "already-played world. This can lead to some strange "
1250 "behavior.\n\n"
1251 "Are you sure you wish to keep this world?"
1252 );
1253
1254 while( !decided ) {
1255 uilist smenu;
1256 smenu.allow_cancel = false;
1257 smenu.addentry( 0, true, 'r', "%s", _( "Reset world" ) );
1258 smenu.addentry( 1, true, 'd', "%s", _( "Delete world" ) );
1259 smenu.addentry( 2, true, 'k', "%s", _( "Keep world" ) );
1260 smenu.query();
1261
1262 switch( smenu.ret ) {
1263 case 0:
1264 queryReset = true;
1265 decided = true;
1266 break;
1267 case 1:
1268 queryDelete = true;
1269 decided = true;
1270 break;
1271 case 2:
1272 decided = query_yn( buffer );
1273 break;
1274 }
1275 }
1276 }
1277
1278 if( queryDelete || get_option<std::string>( "WORLD_END" ) == "delete" ) {
1279 world_generator->delete_world( world_generator->active_world->world_name, true );
1280
1281 } else if( queryReset || get_option<std::string>( "WORLD_END" ) == "reset" ) {
1282 world_generator->delete_world( world_generator->active_world->world_name, false );
1283 }
1284 } else if( get_option<std::string>( "WORLD_END" ) != "keep" ) {
1285 std::string tmpmessage;
1286 for( auto &character : characters ) {
1287 tmpmessage += "\n ";
1288 tmpmessage += character;
1289 }
1290 popup( _( "World retained. Characters remaining:%s" ), tmpmessage );
1291 }
1292 if( gamemode ) {
1293 gamemode = std::make_unique<special_game>(); // null gamemode or something..
1294 }
1295 }
1296
1297 //Reset any offset due to driving
1299
1300 //clear all sound channels
1306
1307 MAPBUFFER.reset();
1309
1310#if defined(__ANDROID__)
1311 quick_shortcuts_map.clear();
1312#endif
1313 return true;
1314}
uint32_t UTF8_getch(const char **src, int *srclen)
Definition: catacharset.cpp:18
int utf8_width(const char *s, const bool ignore_tags)
std::string name
Definition: character.h:1512
A wrapper over a pointer to a curses window.
Definition: cursesdef.h:55
void send(const cata::event &) const
Definition: event_bus.cpp:58
void move_save_to_graveyard(const std::string &dirname)
Definition: game.cpp:2788
bool save_maps()
Definition: game.cpp:3052
std::unique_ptr< special_game > gamemode
Definition: game.h:1103
void death_screen()
Definition: game.cpp:2738
monster_range all_monsters()
Same as all_creatures but iterators only over monsters.
Definition: game.cpp:12549
bool save_factions_missions_npcs()
Definition: game.cpp:3038
void despawn_monster(monster &critter)
Despawn a specific monster, it's stored on the overmap.
Definition: game.cpp:11574
const kill_tracker & get_kill_tracker() const
Definition: game.cpp:968
void write_memorial_file(const std::string &filename, std::string sLastWords)
Writes information about the character out to a text file timestamped with the time of the file was m...
Definition: game.cpp:3151
std::vector< std::string > list_active_characters()
Returns a list of currently active character saves.
Definition: game.cpp:3136
bool save_artifacts()
Definition: game.cpp:3046
memorial_logger & memorial()
Definition: game.cpp:3101
void reset_npc_dispositions()
Definition: game.cpp:3010
int monster_kill_count() const
string_input_popup & max_length(int value)
Maximal amount of Unicode characters that can be given by the user.
const std::string & query_string(bool loop=true, bool draw_only=false)
string_input_popup & window(const catacurses::window &w, const point &start, int endx)
Set the window area where to display the input text.
A duration defined as a number of specific time units.
Definition: calendar.h:180
bool allow_cancel
Definition: ui.h:362
bool has_amount(const itype_id &what, int qty, bool pseudo=true, const std::function< bool(const item &)> &filter=return_true< item >) const
Check instance provides at least qty of an item (.
Definition: visitable.cpp:1108
#define c_white
Definition: color.h:18
#define c_light_gray
Definition: color.h:19
#define c_green
Definition: color.h:22
#define c_magenta
Definition: color.h:25
#define c_brown
Definition: color.h:26
#define c_red
Definition: color.h:21
static const itype_id itype_holybook_bible1("holybook_bible1")
static std::string generate_memorial_filename(const std::string &char_name)
Definition: game.cpp:1003
static const itype_id itype_holybook_bible2("holybook_bible2")
static const itype_id itype_holybook_bible3("holybook_bible3")
@ QUIT_DIED
Definition: game.h:72
@ QUIT_SUICIDE
Definition: game.h:69
const time_point & start_of_cataclysm
Definition: calendar.cpp:33
window newwin(int nlines, int ncols, const point &begin)
Definition: ncurses_def.cpp:34
FMT_CONSTEXPR bool find(Ptr first, Ptr last, T value, Ptr &out)
const size_t size
Definition: om_direction.h:27
void do_player_death_hurt(const player &target, bool death)
Definition: sounds.cpp:1633
void fade_audio_channel(channel channel, int duration)
Definition: sounds.cpp:1618
void fade_audio_group(group group, int duration)
Definition: sounds.cpp:1617
int TERMX
Definition: output.cpp:47
void mvwprintz(const catacurses::window &w, const point &p, const nc_color &FG, const std::string &text)
Definition: output.cpp:2035
int FULL_SCREEN_HEIGHT
Definition: output.cpp:56
int TERMY
Definition: output.cpp:48
void center_print(const catacurses::window &w, const int y, const nc_color &FG, const std::string &text)
Definition: output.cpp:446
void wprintz(const catacurses::window &w, const nc_color &FG, const std::string &text)
Definition: output.cpp:2043
int FULL_SCREEN_WIDTH
Definition: output.cpp:55
void mvwputch(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:477
void draw_border(const catacurses::window &w, nc_color border_color, const std::string &title, nc_color title_color)
Definition: output.cpp:575
int mk_wcwidth(uint32_t ucs)
Definition: wcwidth.cpp:94

References _, uilist::addentry(), all_monsters(), uilist::allow_cancel, sfx::any, c_brown, c_green, c_light_gray, c_magenta, c_red, c_white, center_print(), memorial_logger::clear(), overmapbuffer::clear(), sfx::context_themes, death_screen(), despawn_monster(), sfx::do_player_death_hurt(), draw_border(), events(), sfx::fade_audio_channel(), sfx::fade_audio_group(), sfx::fatigue, detail::find(), FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, g, game_over, gamemode, generate_memorial_filename(), get_kill_tracker(), visitable< T >::has_amount(), Character::has_trait(), itype_holybook_bible1, itype_holybook_bible2, itype_holybook_bible3, list_active_characters(), MAPBUFFER, string_input_popup::max_length(), memorial(), mk_wcwidth(), kill_tracker::monster_kill_count(), move_save_to_graveyard(), mvwprintz(), mvwputch(), Character::name, catacurses::newwin(), overmap_buffer, point_zero, popup(), uilist::query(), string_input_popup::query_string(), query_yn(), QUIT_DIED, QUIT_SUICIDE, mapbuffer::reset(), reset_npc_dispositions(), uilist::ret, save_artifacts(), save_factions_missions_npcs(), save_maps(), event_bus::send(), set_driving_view_offset(), om_direction::size, calendar::start_of_cataclysm, string_format(), TERMX, TERMY, sfx::time_of_day, calendar::turn, u, uquit, UTF8_getch(), utf8_width(), sfx::weather, string_input_popup::window(), world_generator, wprintz(), and write_memorial_file().

Referenced by do_turn().

◆ cleanup_dead()

void game::cleanup_dead ( )

Definition at line 4377 of file game.cpp.

4378{
4379 // Dead monsters need to stay in the tracker until everything else that needs to die does so
4380 // This is because dying monsters can still interact with other dying monsters (@ref Creature::killer)
4381 bool monster_is_dead = critter_tracker->kill_marked_for_death();
4382
4383 bool npc_is_dead = false;
4384 // can't use all_npcs as that does not include dead ones
4385 for( const auto &n : active_npc ) {
4386 if( n->is_dead() ) {
4387 n->die( nullptr ); // make sure this has been called to create corpses etc.
4388 npc_is_dead = true;
4389 }
4390 }
4391
4392 if( monster_is_dead ) {
4393 // From here on, pointers to creatures get invalidated as dead creatures get removed.
4394 critter_tracker->remove_dead();
4395 }
4396
4397 if( npc_is_dead ) {
4398 for( auto it = active_npc.begin(); it != active_npc.end(); ) {
4399 if( ( *it )->is_dead() ) {
4400 remove_npc_follower( ( *it )->getID() );
4401 overmap_buffer.remove_npc( ( *it )->getID() );
4402 it = active_npc.erase( it );
4403 } else {
4404 it++;
4405 }
4406 }
4407 }
4408
4409 critter_died = false;
4410}
void remove_npc_follower(const character_id &id)
Remove follower id from follower set.
Definition: game.cpp:1966
pimpl< Creature_tracker > critter_tracker
Definition: game.h:1021
std::list< shared_ptr_fast< npc > > active_npc
Definition: game.h:1085
bool critter_died
Has anything died in this turn and needs to be cleaned up?
Definition: game.h:1097
shared_ptr_fast< npc > remove_npc(const character_id &id)
Find npc by id and if found, erase it from the npc list and return it ( or return nullptr if not foun...

References active_npc, critter_died, critter_tracker, overmap_buffer, overmapbuffer::remove_npc(), and remove_npc_follower().

Referenced by do_turn(), and monmove().

◆ clear_zombies()

void game::clear_zombies ( )

Redirects to the creature_tracker clear() function.

Definition at line 5051 of file game.cpp.

5052{
5053 critter_tracker->clear();
5054}

References critter_tracker.

Referenced by setup().

◆ control_vehicle()

void game::control_vehicle ( )
private

Definition at line 5465 of file game.cpp.

5466{
5467 static const itype_id fuel_type_animal( "animal" );
5468 int veh_part = -1;
5469 vehicle *veh = remoteveh();
5470 if( veh == nullptr ) {
5471 if( const optional_vpart_position vp = m.veh_at( u.pos() ) ) {
5472 veh = &vp->vehicle();
5473 veh_part = vp->part_index();
5474 }
5475 }
5476 if( veh != nullptr && veh->player_in_control( u ) &&
5477 veh->avail_part_with_feature( veh_part, "CONTROLS", true ) >= 0 ) {
5478 veh->use_controls( u.pos() );
5479 } else if( veh && veh->player_in_control( u ) &&
5480 veh->avail_part_with_feature( veh_part, "CONTROL_ANIMAL", true ) >= 0 ) {
5481 u.controlling_vehicle = false;
5482 add_msg( m_info, _( "You let go of the reins." ) );
5483 } else if( veh && ( veh->avail_part_with_feature( veh_part, "CONTROLS", true ) >= 0 ||
5484 ( veh->avail_part_with_feature( veh_part, "CONTROL_ANIMAL", true ) >= 0 &&
5485 veh->has_engine_type( fuel_type_animal, false ) && veh->has_harnessed_animal() ) ) &&
5486 u.in_vehicle ) {
5487 if( u.has_trait( trait_WAYFARER ) ) {
5488 add_msg( m_info, _( "You refuse to take control of this vehicle." ) );
5489 return;
5490 }
5491 if( !veh->interact_vehicle_locked() ) {
5492 veh->handle_potential_theft( dynamic_cast<player &>( u ) );
5493 return;
5494 }
5495 if( veh->engine_on ) {
5496 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5497 return;
5498 }
5499 u.controlling_vehicle = true;
5500 add_msg( _( "You take control of the %s." ), veh->name );
5501 } else {
5502 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5503 return;
5504 }
5505 veh->start_engines( true );
5506 }
5507 } else { // Start looking for nearby vehicle controls.
5508 int num_valid_controls = 0;
5509 cata::optional<tripoint> vehicle_position;
5510 cata::optional<vpart_reference> vehicle_controls;
5511 for( const tripoint elem : m.points_in_radius( g->u.pos(), 1 ) ) {
5512 if( const optional_vpart_position vp = m.veh_at( elem ) ) {
5513 const cata::optional<vpart_reference> controls = vp.value().part_with_feature( "CONTROLS", true );
5514 if( controls ) {
5515 num_valid_controls++;
5516 vehicle_position = elem;
5517 vehicle_controls = controls;
5518 }
5519 }
5520 }
5521 if( num_valid_controls < 1 ) {
5522 add_msg( _( "No vehicle controls found." ) );
5523 return;
5524 } else if( num_valid_controls > 1 ) {
5525 vehicle_position = choose_adjacent( _( "Control vehicle where?" ) );
5526 if( !vehicle_position ) {
5527 return;
5528 }
5529 const optional_vpart_position vp = m.veh_at( *vehicle_position );
5530 if( vp ) {
5531 vehicle_controls = vp.value().part_with_feature( "CONTROLS", true );
5532 if( !vehicle_controls ) {
5533 add_msg( _( "The vehicle doesn't have controls there." ) );
5534 return;
5535 }
5536 } else {
5537 add_msg( _( "No vehicle there." ) );
5538 return;
5539 }
5540 }
5541 // If we hit neither of those, there's only one set of vehicle controls, which should already have been found.
5542 if( vehicle_controls ) {
5543 veh = &vehicle_controls->vehicle();
5544 if( !veh->handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
5545 return;
5546 }
5547 veh->use_controls( *vehicle_position );
5548 //May be folded up (destroyed), so need to re-get it
5549 veh = g->remoteveh();
5550 }
5551 }
5552 if( veh ) {
5553 // If we reached here, we gained control of a vehicle.
5554 // Clear the map memory for the area covered by the vehicle to eliminate ghost vehicles.
5555 for( const tripoint &target : veh->get_points() ) {
5556 u.clear_memorized_tile( m.getabs( target ) );
5557 }
5558 veh->is_following = false;
5559 veh->is_patrolling = false;
5560 veh->autopilot_on = false;
5561 veh->is_autodriving = false;
5562 }
5563}
cata::optional< tripoint > choose_adjacent(const std::string &message, const bool allow_vertical)
Request player input of adjacent tile, possibly including vertical tiles.
Definition: action.cpp:1017
bool in_vehicle
Definition: character.h:1519
void clear_memorized_tile(const tripoint &pos)
Definition: avatar.cpp:165
vehicle * remoteveh()
Returns the current remotely controlled vehicle.
Definition: game.cpp:2574
tripoint_range< tripoint > points_in_radius(const tripoint &center, size_t radius, size_t radiusz=0) const
Definition: map.cpp:8559
optional_vpart_position veh_at(const tripoint &p) const
Checks if tile is occupied by vehicle and by which part.
Definition: map.cpp:1004
Simple wrapper to forward functions that may return a cata::optional to vpart_position.
Definition: player.h:90
bool engine_on
Definition: vehicle.h:1989
std::set< tripoint > & get_points(bool force_refresh=false)
Definition: vehicle.cpp:6758
bool handle_potential_theft(player &p, bool check_only=false, bool prompt=true)
Definition: vehicle.cpp:4377
std::string name
Definition: vehicle.h:1849
bool has_engine_type(const itype_id &ft, bool enabled) const
Definition: vehicle.cpp:1031
void start_engines(bool take_control=false, bool autodrive=false)
void use_controls(const tripoint &pos)
Operate vehicle controls.
vehicle(const vproto_id &type_id, int init_veh_fuel=-1, int init_veh_status=-1)
Definition: vehicle.cpp:251
bool has_harnessed_animal() const
bool interact_vehicle_locked()
int avail_part_with_feature(int p, const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2545
bool autopilot_on
Definition: vehicle.h:1997
bool is_autodriving
Definition: vehicle.h:1982
cata::optional< vpart_reference > part_with_feature(const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2461
static const trait_id trait_WAYFARER("WAYFARER")

References _, add_msg(), vehicle::autopilot_on, vehicle::avail_part_with_feature(), choose_adjacent(), avatar::clear_memorized_tile(), Character::controlling_vehicle, vehicle::engine_on, fuel_type_animal, g, vehicle::get_points(), map::getabs(), vehicle::handle_potential_theft(), vehicle::has_engine_type(), vehicle::has_harnessed_animal(), Character::has_trait(), Character::in_vehicle, vehicle::interact_vehicle_locked(), vehicle::is_autodriving, vehicle::is_following, vehicle::is_patrolling, m, m_info, vehicle::name, vpart_position::part_with_feature(), vehicle::player_in_control(), map::points_in_radius(), Character::pos(), remoteveh(), vehicle::start_engines(), trait_WAYFARER, u, vehicle::use_controls(), cata::optional< T >::value(), map::veh_at(), and vehicle::vehicle().

Referenced by handle_action().

◆ create_or_get_main_ui_adaptor()

shared_ptr_fast< ui_adaptor > game::create_or_get_main_ui_adaptor ( )

In tiles mode w_terrain can have a different font (with a different tile dimension) or can be drawn by cata_tiles which uses tiles that again might have a different dimension then the normal font used everywhere else.

TERRAIN_WINDOW_WIDTH/TERRAIN_WINDOW_HEIGHT defines how many squares can be displayed in w_terrain (using it's specific tile dimension), not including partially drawn squares at the right/bottom. You should use it whenever you want to draw specific squares in that window or to determine whether a specific square is draw on screen (or outside the screen and needs scrolling).

TERRAIN_WINDOW_TERM_WIDTH/TERRAIN_WINDOW_TERM_HEIGHT defines the size of w_terrain in the standard font dimension (the font that everything else uses). You usually don't have to use it, expect for positioning of windows, because the window positions use the standard font dimension.

The code here calculates size available for w_terrain, caps it at max_view_size (the maximal view range than any character can have at any time). It is stored in TERRAIN_WINDOW_*.

Definition at line 3288 of file game.cpp.

3289{
3291 if( !ui ) {
3292 main_ui_adaptor = ui = make_shared_fast<ui_adaptor>();
3293 ui->on_redraw( []( const ui_adaptor & ) {
3294 g->draw();
3295 } );
3296 ui->on_screen_resize( [this]( ui_adaptor & ui ) {
3297 // remove some space for the sidebar, this is the maximal space
3298 // (using standard font) that the terrain window can have
3299 const int sidebar_left = panel_manager::get_manager().get_width_left();
3300 const int sidebar_right = panel_manager::get_manager().get_width_right();
3301
3303 TERRAIN_WINDOW_WIDTH = TERMX - ( sidebar_left + sidebar_right );
3306
3307 /**
3308 * In tiles mode w_terrain can have a different font (with a different
3309 * tile dimension) or can be drawn by cata_tiles which uses tiles that again
3310 * might have a different dimension then the normal font used everywhere else.
3311 *
3312 * TERRAIN_WINDOW_WIDTH/TERRAIN_WINDOW_HEIGHT defines how many squares can
3313 * be displayed in w_terrain (using it's specific tile dimension), not
3314 * including partially drawn squares at the right/bottom. You should
3315 * use it whenever you want to draw specific squares in that window or to
3316 * determine whether a specific square is draw on screen (or outside the screen
3317 * and needs scrolling).
3318 *
3319 * TERRAIN_WINDOW_TERM_WIDTH/TERRAIN_WINDOW_TERM_HEIGHT defines the size of
3320 * w_terrain in the standard font dimension (the font that everything else uses).
3321 * You usually don't have to use it, expect for positioning of windows,
3322 * because the window positions use the standard font dimension.
3323 *
3324 * The code here calculates size available for w_terrain, caps it at
3325 * max_view_size (the maximal view range than any character can have at
3326 * any time).
3327 * It is stored in TERRAIN_WINDOW_*.
3328 */
3330
3331 // Position of the player in the terrain window, it is always in the center
3334
3336 point( sidebar_left, 0 ) );
3337
3338 // minimap is always MINIMAP_WIDTH x MINIMAP_HEIGHT in size
3340
3341 // need to init in order to avoid crash. gets updated by the panel code.
3343
3344 ui.position_from_window( catacurses::stdscr );
3345 } );
3346 ui->mark_resize();
3347 }
3348 return ui;
3349}
catacurses::window w_pixel_minimap
Definition: game.h:1039
catacurses::window w_minimap_ptr
Definition: game.h:1076
weak_ptr_fast< ui_adaptor > main_ui_adaptor
Definition: game.h:1122
catacurses::window w_minimap
Definition: game.h:1038
catacurses::window w_terrain_ptr
Definition: game.h:1075
static panel_manager & get_manager()
Definition: panels.h:72
int get_width_right()
Definition: panels.cpp:2293
int get_width_left()
Definition: panels.cpp:2301
static constexpr int MINIMAP_WIDTH
static constexpr int MINIMAP_HEIGHT
void to_map_font_dimension(int &, int &)
Definition: game_ui.cpp:20
std::shared_ptr< T > shared_ptr_fast
Definition: memory_fast.h:16
window stdscr
int TERRAIN_WINDOW_TERM_WIDTH
Definition: output.cpp:53
int TERRAIN_WINDOW_TERM_HEIGHT
Definition: output.cpp:54
int POSX
Definition: output.cpp:49
int TERRAIN_WINDOW_WIDTH
Definition: output.cpp:51
int POSY
Definition: output.cpp:50
int TERRAIN_WINDOW_HEIGHT
Definition: output.cpp:52

References g, panel_manager::get_manager(), panel_manager::get_width_left(), panel_manager::get_width_right(), main_ui_adaptor, MINIMAP_HEIGHT, MINIMAP_WIDTH, catacurses::newwin(), point_zero, POSX, POSY, catacurses::stdscr, TERMX, TERMY, TERRAIN_WINDOW_HEIGHT, TERRAIN_WINDOW_TERM_HEIGHT, TERRAIN_WINDOW_TERM_WIDTH, TERRAIN_WINDOW_WIDTH, to_map_font_dimension(), w_minimap, w_minimap_ptr, w_pixel_minimap, w_terrain, and w_terrain_ptr.

◆ create_starting_npcs()

void game::create_starting_npcs ( )
private

Definition at line 973 of file game.cpp.

974{
975 if( !get_option<bool>( "STATIC_NPC" ) ||
976 get_option<std::string>( "STARTING_NPC" ) == "never" ) {
977 return; //Do not generate a starting npc.
978 }
979
980 //We don't want more than one starting npc per starting location
981 const int radius = 1;
982 if( !overmap_buffer.get_npcs_near_player( radius ).empty() ) {
983 return; //There is already an NPC in this starting location
984 }
985
986 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
987 tmp->normalize();
988 tmp->randomize( one_in( 2 ) ? NC_DOCTOR : NC_NONE );
989 tmp->spawn_at_precise( { get_levx(), get_levy() }, u.pos() - point_south_east );
991 tmp->form_opinion( u );
992 tmp->set_attitude( NPCATT_NULL );
993 //This sets the NPC mission. This NPC remains in the starting location.
994 tmp->mission = NPC_MISSION_SHELTER;
995 tmp->chatbin.first_topic = "TALK_SHELTER";
996 tmp->toggle_trait( trait_id( "NPC_STARTING_NPC" ) );
997 tmp->set_fac( faction_id( "no_faction" ) );
998 //One random starting NPC mission
999 tmp->add_new_mission( mission::reserve_random( ORIGIN_OPENER_NPC, tmp->global_omt_location(),
1000 tmp->getID() ) );
1001}
int get_levy() const
Definition: game.cpp:12439
int get_levx() const
The top left corner of the reality bubble (in submaps coordinates).
Definition: game.cpp:12434
static mission * reserve_random(mission_origin origin, const tripoint_abs_omt &p, const character_id &npc_id)
Definition: mission.cpp:200
std::vector< shared_ptr_fast< npc > > get_npcs_near_player(int radius)
Same as get_npcs_near(int,int,int,int) but uses player position as center.
void insert_npc(const shared_ptr_fast< npc > &who)
Adds the npc to an overmap ( based on the npcs current location ) and stores it there.
string_id< faction > faction_id
Definition: clzones.h:30
@ ORIGIN_OPENER_NPC
Definition: mission.h:45
@ NPCATT_NULL
Definition: npc.h:81
@ NPC_MISSION_SHELTER
Definition: npc.h:181
npc_class_id NC_NONE("NC_NONE")
npc_class_id NC_DOCTOR("NC_DOCTOR")
static constexpr point point_south_east
Definition: point.h:279
bool one_in(int chance)
Definition: rng.cpp:65

References get_levx(), get_levy(), overmapbuffer::get_npcs_near_player(), overmapbuffer::insert_npc(), NC_DOCTOR, NC_NONE, NPC_MISSION_SHELTER, NPCATT_NULL, one_in(), ORIGIN_OPENER_NPC, overmap_buffer, point_south_east, Character::pos(), mission::reserve_random(), trait_id, and u.

Referenced by start_game().

◆ critter_at() [1/2]

template<typename T >
T * game::critter_at ( const tripoint p,
bool  allow_hallucination = false 
)

Returns the Creature at the given location.

Optionally casted to the given type of creature: npc, player, monster - if there is a creature, but it's not of the requested type, returns nullptr.

Parameters
allow_hallucinationWhether to return monsters that are actually hallucinations.

Definition at line 4856 of file game.cpp.

4857{
4858 if( const shared_ptr_fast<monster> mon_ptr = critter_tracker->find( p ) ) {
4859 if( !allow_hallucination && mon_ptr->is_hallucination() ) {
4860 return nullptr;
4861 }
4862 // if we wanted to check for an NPC / player / avatar,
4863 // there is sometimes a monster AND an NPC/player there at the same time.
4864 // because the NPC/player etc may be riding that monster.
4865 // so only return the monster if we were actually looking for a monster.
4866 // otherwise, keep looking for the rider.
4867 // critter_at<creature> or critter_at() with no template will still default to returning monster first,
4868 // which is ok for the occasions where that happens.
4869 if( !mon_ptr->has_effect( effect_ridden ) || ( std::is_same<T, monster>::value ||
4870 std::is_same<T, Creature>::value || std::is_same<T, const monster>::value ||
4871 std::is_same<T, const Creature>::value ) ) {
4872 return dynamic_cast<T *>( mon_ptr.get() );
4873 }
4874 }
4875 if( !std::is_same<T, npc>::value && !std::is_same<T, const npc>::value ) {
4876 if( p == u.pos() ) {
4877 return dynamic_cast<T *>( &u );
4878 }
4879 }
4880 for( auto &cur_npc : active_npc ) {
4881 if( cur_npc->pos() == p && !cur_npc->is_dead() ) {
4882 return dynamic_cast<T *>( cur_npc.get() );
4883 }
4884 }
4885 return nullptr;
4886}
static const efftype_id effect_ridden("ridden")

References active_npc, critter_tracker, effect_ridden, Character::pos(), and u.

Referenced by draw_look_around_cursor(), examine(), find_or_make_stairs(), fling_creature(), forced_door_closing(), get_player_input(), is_empty(), knockback(), phasing_move(), print_all_tile_info(), spawn_hallucination(), swap_critters(), and update_stair_monsters().

◆ critter_at() [2/2]

template<typename T >
const T * game::critter_at ( const tripoint p,
bool  allow_hallucination = false 
) const

Definition at line 4889 of file game.cpp.

4890{
4891 return const_cast<game *>( this )->critter_at<T>( p, allow_hallucination );
4892}
Definition: game.h:144

◆ critter_by_id()

template<typename T >
template Creature * game::critter_by_id< Creature > ( const character_id id)
Returns
The living creature with the given id. Returns null if no living creature with such an id exists. Never returns a dead creature. Currently only the player character and npcs have ids.

Definition at line 4935 of file game.cpp.

4936{
4937 if( id == u.getID() ) {
4938 // player is always alive, therefore no is-dead check
4939 return dynamic_cast<T *>( &u );
4940 }
4941 return find_npc( id );
4942}
character_id getID() const
Definition: character.cpp:477
npc * find_npc(character_id id)
Find the npc with the given ID.
Definition: game.cpp:1955

References find_npc(), Character::getID(), and u.

◆ death_screen()

void game::death_screen ( )
private

Definition at line 2738 of file game.cpp.

2739{
2740 gamemode->game_over();
2744 follower_ids.clear();
2746}
stats_tracker & stats()
Definition: game.cpp:3096
void disp_NPC_epilogues()
Definition: game.cpp:3175
void display_faction_epilogues()
Definition: game.cpp:3192
void display_messages()
Definition: messages.cpp:801
void show_scores_ui(const achievements_tracker &achievements, stats_tracker &stats, const kill_tracker &kills)
Definition: scores_ui.cpp:69

References achievements_tracker_ptr, disp_NPC_epilogues(), display_faction_epilogues(), Messages::display_messages(), follower_ids, gamemode, get_kill_tracker(), show_scores_ui(), and stats().

Referenced by cleanup_at_end().

◆ despawn_monster()

void game::despawn_monster ( monster critter)

Despawn a specific monster, it's stored on the overmap.

Also removes it from the creature tracker. Keep in mind that any monster index may point to a different monster after calling this (or to no monster at all).

Definition at line 11574 of file game.cpp.

11575{
11576 if( !critter.is_hallucination() ) {
11577 // hallucinations aren't stored, they come and go as they like,
11579 }
11580
11581 critter.on_unload();
11582 remove_zombie( critter );
11583 // simulate it being dead so further processing of it (e.g. in monmove) will yield
11584 critter.set_hp( 0 );
11585}
void remove_zombie(const monster &critter)
Definition: game.cpp:5046
bool is_hallucination() const override
Definition: monster.cpp:2652
void on_unload()
Do some cleanup and caching as monster is being unloaded from map.
Definition: monster.cpp:2984
void set_hp(int hp)
Directly set the current hp of the monster (not capped at the maximal hp).
Definition: monster.cpp:1635
void despawn_monster(const monster &critter)
Despawn the monster back onto the overmap.

References overmapbuffer::despawn_monster(), monster::is_hallucination(), monster::on_unload(), overmap_buffer, remove_zombie(), and monster::set_hp().

Referenced by cleanup_at_end(), monmove(), place_player_overmap(), and shift_monsters().

◆ disable_robot()

bool game::disable_robot ( const tripoint p)

If there is a robot (that can be disabled), query the player and try to disable it.

Returns
true if the robot has been disabled or a similar action has been done. false if the player did not choose any action and the function has effectively done nothing.

Definition at line 9198 of file game.cpp.

9199{
9200 monster *const mon_ptr = critter_at<monster>( p );
9201 if( !mon_ptr ) {
9202 return false;
9203 }
9204 monster &critter = *mon_ptr;
9205 if( critter.friendly == 0 || critter.has_flag( MF_RIDEABLE_MECH ) ||
9206 ( critter.has_flag( MF_PAY_BOT ) && critter.has_effect( effect_paid ) ) ) {
9207 // Can only disable / reprogram friendly monsters
9208 return false;
9209 }
9210 const auto mid = critter.type->id;
9211 const auto mon_item_id = critter.type->revert_to_itype;
9212 if( !mon_item_id.is_empty() &&
9213 query_yn( _( "Deactivate the %s?" ), critter.name() ) ) {
9214
9215 u.moves -= 100;
9216 m.add_item_or_charges( p, critter.to_item() );
9217 if( !critter.has_flag( MF_INTERIOR_AMMO ) ) {
9218 for( auto &ammodef : critter.ammo ) {
9219 if( ammodef.second > 0 ) {
9220 m.spawn_item( p.xy(), ammodef.first, 1, ammodef.second, calendar::turn );
9221 }
9222 }
9223 }
9224 remove_zombie( critter );
9225 return true;
9226 }
9227 // Manhacks are special, they have their own menu here.
9228 if( mid == mon_manhack ) {
9229 int choice = UILIST_CANCEL;
9230 if( critter.has_effect( effect_docile ) ) {
9231 choice = uilist( _( "Reprogram the manhack?" ), { _( "Engage targets." ) } );
9232 } else {
9233 choice = uilist( _( "Reprogram the manhack?" ), { _( "Follow me." ) } );
9234 }
9235 switch( choice ) {
9236 case 0:
9237 if( critter.has_effect( effect_docile ) ) {
9238 critter.remove_effect( effect_docile );
9239 if( one_in( 3 ) ) {
9240 add_msg( _( "The %s hovers momentarily as it surveys the area." ),
9241 critter.name() );
9242 }
9243 } else {
9244 critter.add_effect( effect_docile, 1_turns, num_bp );
9245 if( one_in( 3 ) ) {
9246 add_msg( _( "The %s lets out a whirring noise and starts to follow you." ),
9247 critter.name() );
9248 }
9249 }
9250 u.moves -= 100;
9251 return true;
9252 default:
9253 break;
9254 }
9255 }
9256 return false;
9257}
@ num_bp
Definition: bodypart.h:52
bool remove_effect(const efftype_id &eff_id, body_part bp=num_bp)
Removes a listed effect.
Definition: creature.cpp:1136
void spawn_item(const tripoint &p, const itype_id &type_id, unsigned quantity=1, int charges=0, const time_point &birthday=calendar::start_of_cataclysm, int damlevel=0)
Definition: map.cpp:4173
bool has_flag(m_flag f) const override
Definition: monster.cpp:869
item to_item() const
Convert this monster into an item (see mtype::revert_to_itype).
Definition: monster.cpp:2792
void add_effect(const efftype_id &eff_id, const time_duration &dur, const bodypart_str_id &bp, int intensity=0, bool force=false, bool deferred=false) override
Performs any monster-specific modifications to the arguments before passing to Creature::add_effect()...
Definition: monster.cpp:1811
int friendly
Definition: monster.h:473
std::string name(unsigned int quantity=1) const
Definition: monster.cpp:492
std::map< itype_id, int > ammo
Definition: monster.h:514
static const efftype_id effect_docile("docile")
static const efftype_id effect_paid("paid")
static const mtype_id mon_manhack("mon_manhack")
@ MF_INTERIOR_AMMO
Definition: mtype.h:146
@ MF_RIDEABLE_MECH
Definition: mtype.h:115
@ MF_PAY_BOT
Definition: mtype.h:121
itype_id revert_to_itype
If this is not empty, the monster can be converted into an item of this type (if it's friendly).
Definition: mtype.h:361
constexpr point xy() const
Definition: point.h:220
const int UILIST_CANCEL
Definition: ui.h:28

References _, monster::add_effect(), map::add_item_or_charges(), add_msg(), monster::ammo, effect_docile, effect_paid, monster::friendly, Creature::has_effect(), monster::has_flag(), mtype::id, m, MF_INTERIOR_AMMO, MF_PAY_BOT, MF_RIDEABLE_MECH, mon_manhack, Creature::moves, monster::name(), num_bp, one_in(), query_yn(), Creature::remove_effect(), remove_zombie(), mtype::revert_to_itype, map::spawn_item(), monster::to_item(), calendar::turn, monster::type, u, UILIST_CANCEL, and tripoint::xy().

Referenced by examine().

◆ disp_NPC_epilogues()

void game::disp_NPC_epilogues ( )
private

Definition at line 3175 of file game.cpp.

3176{
3177 // TODO: This search needs to be expanded to all NPCs
3178 for( auto elem : follower_ids ) {
3180 if( !guy ) {
3181 continue;
3182 }
3183 const auto new_win = []() {
3185 point( std::max( 0, ( TERMX - FULL_SCREEN_WIDTH ) / 2 ),
3186 std::max( 0, ( TERMY - FULL_SCREEN_HEIGHT ) / 2 ) ) );
3187 };
3188 scrollable_text( new_win, guy->disp_name(), guy->get_epilogue() );
3189 }
3190}
shared_ptr_fast< npc > find_npc(character_id id)
Find the npc with the given ID.
void scrollable_text(const std::function< catacurses::window()> &init_window, const std::string &title, const std::string &text)
Definition: output.cpp:352

References overmapbuffer::find_npc(), follower_ids, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, catacurses::newwin(), overmap_buffer, scrollable_text(), TERMX, and TERMY.

Referenced by death_screen().

◆ disp_NPCs()

void game::disp_NPCs ( )

Definition at line 3226 of file game.cpp.

3227{
3228 const tripoint_abs_omt ppos = u.global_omt_location();
3229 const tripoint &lpos = u.pos();
3230 std::vector<shared_ptr_fast<npc>> npcs = overmap_buffer.get_npcs_near_player( 100 );
3231 std::sort( npcs.begin(), npcs.end(), npc_dist_to_player() );
3232
3234 ui_adaptor ui;
3235 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
3238 TERMY > FULL_SCREEN_HEIGHT ? ( TERMY - FULL_SCREEN_HEIGHT ) / 2 : 0 ) );
3239 ui.position_from_window( w );
3240 } );
3241 ui.mark_resize();
3242 ui.on_redraw( [&]( const ui_adaptor & ) {
3243 werase( w );
3244 mvwprintz( w, point_zero, c_white, _( "Your overmap position: %s" ), ppos.to_string() );
3245 // NOLINTNEXTLINE(cata-use-named-point-constants)
3246 mvwprintz( w, point( 0, 1 ), c_white, _( "Your local position: %s" ), lpos.to_string() );
3247 size_t i;
3248 for( i = 0; i < 20 && i < npcs.size(); i++ ) {
3249 const tripoint_abs_omt apos = npcs[i]->global_omt_location();
3250 mvwprintz( w, point( 0, i + 3 ), c_white, "%s: %s", npcs[i]->name,
3251 apos.to_string() );
3252 }
3253 for( const monster &m : all_monsters() ) {
3254 mvwprintz( w, point( 0, i + 3 ), c_white, "%s: %d, %d, %d", m.name(),
3255 m.posx(), m.posy(), m.posz() );
3256 ++i;
3257 }
3258 wnoutrefresh( w );
3259 } );
3260
3261 input_context ctxt( "DISP_NPCS" );
3262 ctxt.register_action( "CONFIRM" );
3263 ctxt.register_action( "QUIT" );
3264 ctxt.register_action( "HELP_KEYBINDINGS" );
3265 bool stop = false;
3266 while( !stop ) {
3268 const std::string action = ctxt.handle_input();
3269 if( action == "CONFIRM" || action == "QUIT" ) {
3270 stop = true;
3271 }
3272 }
3273}
tripoint_abs_omt global_omt_location() const
Returns the location of the player in global overmap terrain coordinates.
Definition: character.cpp:6351
std::string to_string() const
Definition: coordinates.h:140
Represents a context in which a set of actions can be performed.
Definition: input.h:382
std::string name(const tripoint &p)
Definition: map.cpp:1320
void wnoutrefresh(const window &win)
Definition: ncurses_def.cpp:43
void werase(const window &win)
Definition: ncurses_def.cpp:53
std::string to_string() const
Definition: point.cpp:16

References _, action, all_monsters(), c_white, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, overmapbuffer::get_npcs_near_player(), Character::global_omt_location(), input_context::handle_input(), m, mvwprintz(), map::name(), om_direction::name(), catacurses::newwin(), overmap_buffer, point_zero, Character::pos(), ui_manager::redraw(), input_context::register_action(), TERMX, TERMY, coords::coord_point< Point, Origin, Scale >::to_string(), tripoint::to_string(), u, catacurses::werase(), and catacurses::wnoutrefresh().

◆ display_faction_epilogues()

void game::display_faction_epilogues ( )
private

Definition at line 3192 of file game.cpp.

3193{
3194 for( const auto &elem : faction_manager_ptr->all() ) {
3195 if( elem.second.known_by_u ) {
3196 const std::vector<std::string> epilogue = elem.second.epilogue();
3197 if( !epilogue.empty() ) {
3198 const auto new_win = []() {
3200 point( std::max( 0, ( TERMX - FULL_SCREEN_WIDTH ) / 2 ),
3201 std::max( 0, ( TERMY - FULL_SCREEN_HEIGHT ) / 2 ) ) );
3202 };
3203 scrollable_text( new_win, elem.second.name,
3204 std::accumulate( epilogue.begin() + 1, epilogue.end(), epilogue.front(),
3205 []( const std::string & lhs, const std::string & rhs ) -> std::string {
3206 return lhs + "\n" + rhs;
3207 } ) );
3208 }
3209 }
3210 }
3211}
pimpl< faction_manager > faction_manager_ptr
Definition: game.h:1022

References faction_manager_ptr, FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, catacurses::newwin(), scrollable_text(), TERMX, and TERMY.

Referenced by death_screen().

◆ display_lighting()

void game::display_lighting ( )
private

Definition at line 11786 of file game.cpp.

11787{
11788 if( use_tiles ) {
11790 if( !g->display_overlay_state( ACTION_DISPLAY_LIGHTING ) ) {
11791 return;
11792 }
11793 uilist lighting_menu;
11794 std::vector<std::string> lighting_menu_strings{
11795 "Global lighting conditions"
11796 };
11797
11798 int count = 0;
11799 for( const auto &menu_str : lighting_menu_strings ) {
11800 lighting_menu.addentry( count++, true, MENU_AUTOASSIGN, "%s", menu_str );
11801 }
11802
11803 lighting_menu.w_y_setup = 0;
11804 lighting_menu.query();
11805 if( ( lighting_menu.ret >= 0 ) &&
11806 ( static_cast<size_t>( lighting_menu.ret ) < lighting_menu_strings.size() ) ) {
11807 g->displaying_lighting_condition = lighting_menu.ret;
11808 }
11809 }
11810}
@ ACTION_DISPLAY_LIGHTING
Toggle lighting conditions map.
Definition: action.h:317
bool use_tiles
Use tiles for display.
void display_toggle_overlay(action_id)
Definition: game.cpp:11682
pos_scalar w_y_setup
Definition: ui.h:338
constexpr size_t count()
Definition: fmtlib_core.h:1073
const int MENU_AUTOASSIGN
Definition: ui.h:31

References ACTION_DISPLAY_LIGHTING, uilist::addentry(), detail::count(), display_toggle_overlay(), g, MENU_AUTOASSIGN, uilist::query(), uilist::ret, use_tiles, and uilist::w_y_setup.

Referenced by handle_action(), and look_around().

◆ display_overlay_state()

bool game::display_overlay_state ( action_id  action)

Definition at line 11677 of file game.cpp.

11678{
11680}
cata::optional< action_id > displaying_overlays
Definition: game.h:967

References action, and displaying_overlays.

Referenced by display_toggle_overlay(), and display_visibility().

◆ display_radiation()

void game::display_radiation ( )
private

Definition at line 11812 of file game.cpp.

11813{
11814 if( use_tiles ) {
11816 }
11817}
@ ACTION_DISPLAY_RADIATION
Toggle radiation map.
Definition: action.h:319

References ACTION_DISPLAY_RADIATION, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_scent()

void game::display_scent ( )
private

Definition at line 11691 of file game.cpp.

11692{
11693 if( use_tiles ) {
11695 } else {
11696 int div;
11697 bool got_value = query_int( div, _( "Set the Scent Map sensitivity to (0 to cancel)?" ) );
11698 if( !got_value || div < 1 ) {
11699 add_msg( _( "Never mind." ) );
11700 return;
11701 }
11702 shared_ptr_fast<game::draw_callback_t> scent_cb = make_shared_fast<game::draw_callback_t>( [&]() {
11703 scent.draw( w_terrain, div * 2, u.pos() + u.view_offset );
11704 } );
11705 g->add_draw_callback( scent_cb );
11706
11709 }
11710}
@ ACTION_DISPLAY_SCENT
Toggle scent map.
Definition: action.h:279
void wait_for_any_key()
Wait until the user presses a key.
Definition: input.cpp:1309
tripoint view_offset
Definition: player.h:639
void draw(const catacurses::window &win, int div, const tripoint &center) const
Definition: scent_map.cpp:70
input_manager inp_mngr
Definition: input.cpp:109
bool query_int(int &result, int default_val, const std::string &text)
Definition: output.cpp:718

References _, ACTION_DISPLAY_SCENT, add_msg(), display_toggle_overlay(), scent_map::draw(), g, inp_mngr, Character::pos(), query_int(), ui_manager::redraw(), scent, u, use_tiles, player::view_offset, w_terrain, and input_manager::wait_for_any_key().

Referenced by handle_action(), and look_around().

◆ display_temperature()

void game::display_temperature ( )
private

Definition at line 11712 of file game.cpp.

11713{
11714 if( use_tiles ) {
11716 }
11717}
@ ACTION_DISPLAY_TEMPERATURE
Toggle temperature map.
Definition: action.h:311

References ACTION_DISPLAY_TEMPERATURE, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_toggle_overlay()

void game::display_toggle_overlay ( action_id  action)

Definition at line 11682 of file game.cpp.

11683{
11684 if( display_overlay_state( action ) ) {
11685 displaying_overlays.reset();
11686 } else {
11688 }
11689}
bool display_overlay_state(action_id)
Definition: game.cpp:11677

References action, display_overlay_state(), and displaying_overlays.

Referenced by display_lighting(), display_radiation(), display_scent(), display_temperature(), display_transparency(), display_vehicle_ai(), and display_visibility().

◆ display_transparency()

void game::display_transparency ( )
private

Definition at line 11819 of file game.cpp.

11820{
11821 if( use_tiles ) {
11823 }
11824}
@ ACTION_DISPLAY_TRANSPARENCY
Toggle transparency map.
Definition: action.h:321

References ACTION_DISPLAY_TRANSPARENCY, display_toggle_overlay(), and use_tiles.

Referenced by handle_action(), and look_around().

◆ display_vehicle_ai()

void game::display_vehicle_ai ( )
private

Definition at line 11719 of file game.cpp.

11720{
11721 if( use_tiles ) {
11723 }
11724}
@ ACTION_DISPLAY_VEHICLE_AI
Toggle vehicle autopilot data.
Definition: action.h:313

References ACTION_DISPLAY_VEHICLE_AI, display_toggle_overlay(), and use_tiles.

Referenced by handle_action().

◆ display_visibility()

void game::display_visibility ( )
private

Definition at line 11726 of file game.cpp.

11727{
11728 if( use_tiles ) {
11731 std::vector< tripoint > locations;
11732 uilist creature_menu;
11733 int num_creatures = 0;
11734 creature_menu.addentry( num_creatures++, true, MENU_AUTOASSIGN, "%s", _( "You" ) );
11735 locations.emplace_back( g->u.pos() ); // add player first.
11736 for( const Creature &critter : g->all_creatures() ) {
11737 if( critter.is_player() ) {
11738 continue;
11739 }
11740 creature_menu.addentry( num_creatures++, true, MENU_AUTOASSIGN, critter.disp_name() );
11741 locations.emplace_back( critter.pos() );
11742 }
11743
11744 pointmenu_cb callback( locations );
11745 creature_menu.callback = &callback;
11746 creature_menu.w_y_setup = 0;
11747 creature_menu.query();
11748 if( creature_menu.ret >= 0 && static_cast<size_t>( creature_menu.ret ) < locations.size() ) {
11749 Creature *creature = critter_at<Creature>( locations[creature_menu.ret] );
11751 }
11752 } else {
11754 }
11755 }
11756}
@ ACTION_DISPLAY_VISIBILITY
Toggle visibility map.
Definition: action.h:315
size_t num_creatures() const
Returns the approximate number of creatures in the reality bubble.
Definition: game.cpp:5036
Creature * displaying_visibility_creature
Creature for which to display the visibility map.
Definition: game.h:1058
Callback for uilist that pairs menu entries with points When an entry is selected,...
Definition: ui.h:423
uilist_callback * callback
Definition: ui.h:335
generic_factory< overmap_location > locations("overmap location")

References _, ACTION_DISPLAY_VISIBILITY, uilist::addentry(), uilist::callback, creature, display_overlay_state(), display_toggle_overlay(), displaying_visibility_creature, g, anonymous_namespace{overmap_location.cpp}::locations, MENU_AUTOASSIGN, num_creatures(), uilist::query(), uilist::ret, use_tiles, and uilist::w_y_setup.

Referenced by handle_action().

◆ do_turn()

bool game::do_turn ( )

MAIN GAME LOOP.

Returns true if game is over (death, saved, quit, etc.).

Definition at line 1436 of file game.cpp.

1437{
1438 if( is_game_over() ) {
1439 return cleanup_at_end();
1440 }
1441 // Actual stuff
1442 if( new_game ) {
1443 new_game = false;
1444 } else {
1445 gamemode->per_turn();
1446 calendar::turn += 1_turns;
1447 }
1448
1449 // starting a new turn, clear out temperature cache
1451 weather.clear_temp_cache();
1452
1453 if( npcs_dirty ) {
1454 load_npcs();
1455 }
1456
1459 // If controlling a vehicle that is owned by someone else
1461 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
1462 if( veh && !veh->handle_potential_theft( dynamic_cast<player &>( u ), true ) ) {
1463 veh->handle_potential_theft( dynamic_cast<player &>( u ), false, false );
1464 }
1465 }
1466 // If riding a horse - chance to spook
1467 if( u.is_mounted() ) {
1469 }
1470 if( calendar::once_every( 1_days ) ) {
1472 }
1473
1474 // Move hordes every 2.5 min
1477 // Hordes that reached the reality bubble need to spawn,
1478 // make them spawn in invisible areas only.
1479 m.spawn_monsters( false );
1480 }
1481
1483
1484 u.update_body();
1485
1486 // Auto-save if autosave is enabled
1487 if( get_option<bool>( "AUTOSAVE" ) &&
1488 calendar::once_every( 1_turns * get_option<int>( "AUTOSAVE_TURNS" ) ) &&
1489 !u.is_dead_state() ) {
1490 autosave();
1491 }
1492
1493 weather.update_weather();
1495
1499 // Process NPC sound events before they move or they hear themselves talking
1500 for( npc &guy : all_npcs() ) {
1501 if( rl_dist( guy.pos(), u.pos() ) < MAX_VIEW_DISTANCE ) {
1503 }
1504 }
1505
1506 // Process sound events into sound markers for display to the player.
1508
1509 if( u.is_deaf() ) {
1511 }
1512
1513 if( !u.has_effect( effect_sleep ) || uquit == QUIT_WATCH ) {
1514 if( u.moves > 0 || uquit == QUIT_WATCH ) {
1515 while( u.moves > 0 || uquit == QUIT_WATCH ) {
1516 cleanup_dead();
1518 // Process any new sounds the player caused during their turn.
1519 for( npc &guy : all_npcs() ) {
1520 if( rl_dist( guy.pos(), u.pos() ) < MAX_VIEW_DISTANCE ) {
1522 }
1523 }
1526 wait_popup.reset();
1528 }
1529
1530 if( queue_screenshot ) {
1534 queue_screenshot = false;
1535 }
1536
1537 if( handle_action() ) {
1539 u.action_taken();
1540 }
1541
1542 if( is_game_over() ) {
1543 return cleanup_at_end();
1544 }
1545
1546 if( uquit == QUIT_WATCH ) {
1547 break;
1548 }
1549 if( u.activity ) {
1551 }
1552 }
1553 // Reset displayed sound markers now that the turn is over.
1554 // We only want this to happen if the player had a chance to examine the sounds.
1556 }
1557 }
1558
1559 if( driving_view_offset.x != 0 || driving_view_offset.y != 0 ) {
1560 // Still have a view offset, but might not be driving anymore,
1561 // or the option has been deactivated,
1562 // might also happen when someone dives from a moving car.
1563 // or when using the handbrake.
1564 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
1565 calc_driving_offset( veh );
1566 }
1567
1568 // No-scent debug mutation has to be processed here or else it takes time to start working
1569 if( !u.has_active_bionic( bionic_id( "bio_scent_mask" ) ) &&
1570 !u.has_trait( trait_id( "DEBUG_NOSCENT" ) ) ) {
1573 }
1574 scent.update( u.pos(), m );
1575
1576 // We need floor cache before checking falling 'n stuff
1578
1581 m.vehmove();
1582 m.process_fields();
1583 m.process_items();
1586
1587 // Apply sounds from previous turn to monster and NPC AI.
1589 // Update vision caches for monsters. If this turns out to be expensive,
1590 // consider a stripped down cache just for monsters.
1591 m.build_map_cache( get_levz(), true );
1592 monmove();
1593 if( calendar::once_every( 5_minutes ) ) {
1595 }
1596 if( calendar::once_every( 10_seconds ) ) {
1597 for( const tripoint &elem : m.get_furn_field_locations() ) {
1598 const auto &furn = m.furn( elem ).obj();
1599 for( const emit_id &e : furn.emissions ) {
1600 m.emit_field( elem, e );
1601 }
1602 }
1603 }
1606 u.process_turn();
1607
1609 cleanup_dead();
1610
1611 if( u.moves < 0 && get_option<bool>( "FORCE_REDRAW" ) ) {
1614 }
1615
1616 if( get_levz() >= 0 && !u.is_underwater() ) {
1617 handle_weather_effects( weather.weather_id );
1618 }
1619
1620 const bool player_is_sleeping = u.has_effect( effect_sleep );
1621 bool wait_redraw = false;
1622 std::string wait_message;
1623 time_duration wait_refresh_rate;
1624 if( player_is_sleeping ) {
1625 wait_redraw = true;
1626 wait_message = _( "Wait till you wake up…" );
1627 wait_refresh_rate = 30_minutes;
1628 if( calendar::once_every( 1_hours ) ) {
1630 }
1631 } else if( u.has_destination() ) {
1632 wait_redraw = true;
1633 wait_message = _( "Travelling…" );
1634 wait_refresh_rate = 15_turns;
1635 } else if( const cata::optional<std::string> progress = u.activity.get_progress_message( u ) ) {
1636 wait_redraw = true;
1637 wait_message = *progress;
1638 if( u.activity.id() == ACT_AUTODRIVE ) {
1639 wait_refresh_rate = 1_turns;
1640 } else {
1641 wait_refresh_rate = 5_minutes;
1642 }
1643 }
1644 if( wait_redraw ) {
1646 calendar::once_every( std::min( 1_minutes, wait_refresh_rate ) ) ) {
1647 if( first_redraw_since_waiting_started || calendar::once_every( wait_refresh_rate ) ) {
1649 }
1650
1651 // Avoid redrawing the main UI every time due to invalidation
1653 wait_popup = std::make_unique<static_popup>();
1654 wait_popup->on_top( true ).wait_message( "%s", wait_message );
1658 }
1659 } else {
1660 // Nothing to wait for now
1661 wait_popup.reset();
1663 }
1664
1666 u.update_body_wetness( get_weather().get_precise() );
1667 u.apply_wetness_morale( weather.temperature );
1668
1669 if( calendar::once_every( 1_minutes ) ) {
1670 u.update_morale();
1671 }
1672
1673 if( calendar::once_every( 9_turns ) ) {
1675 }
1676
1677 if( !u.is_deaf() ) {
1679 }
1684
1685 // reset player noise
1686 u.volume = 0;
1687
1688 return false;
1689}
void update_morale()
Ticks down morale counters and removes them.
Definition: character.cpp:9014
void action_taken()
Called after every action, invalidates player caches.
Definition: character.cpp:877
bool check_mount_is_spooked()
Definition: character.cpp:1102
void update_bodytemp(const map &m, const weather_manager &weather)
Maintains body temperature.
Definition: character.cpp:5198
bool is_mounted() const
Definition: character.cpp:1143
bool has_destination() const
scenttype_id get_type_of_scent() const
Definition: character.cpp:8773
bool check_and_recover_morale()
Checks permanent morale for consistency and recovers it when an inconsistency is found.
Definition: character.cpp:9141
bool is_deaf() const
Definition: character.cpp:4502
void update_body()
Updates all "biology" by one turn.
Definition: character.cpp:4680
bool has_active_bionic(const bionic_id &b) const
Returns true if the player has the entered bionic id and it is powered on.
Definition: character.cpp:1890
void apply_wetness_morale(int temperature)
Recalculates morale penalty/bonus from wetness based on mutations, equipment and temperature.
Definition: suffer.cpp:1805
virtual bool is_underwater() const
Definition: creature.cpp:174
int get_levz() const
Definition: game.cpp:12444
void overmap_npc_move()
Definition: game.cpp:4537
class game::debug_hour_timer debug_hour_timer
npc_range all_npcs()
Same as all_creatures but iterators only over npcs.
Definition: game.cpp:12554
void monmove()
Definition: game.cpp:4412
void autopilot_vehicles()
process vehicles that are following the player
Definition: game.cpp:1753
void add_artifact_dreams()
Definition: game.cpp:12388
int moves_since_last_save
Definition: game.h:1088
bool take_screenshot() const
Saves a screenshot of the current viewport, as a PNG file.
Definition: game.cpp:7428
void calc_driving_offset(vehicle *veh=nullptr)
Definition: game.cpp:1334
bool cleanup_at_end()
Definition: game.cpp:1030
std::unique_ptr< static_popup > wait_popup
Definition: game.h:1124
bool queue_screenshot
Definition: game.h:1067
friend weather_manager & get_weather()
Definition: weather.cpp:64
void autosave()
Definition: game.cpp:11877
void process_activity()
Definition: game.cpp:1742
void update_stair_monsters()
Definition: game.cpp:11365
void process_voluntary_act_interrupt()
Definition: game.cpp:1703
void load_npcs()
Makes any nearby NPCs on the overmap active.
Definition: game.cpp:898
bool npcs_dirty
Has a NPC been spawned since last load?
Definition: game.h:1095
void cleanup_dead()
Definition: game.cpp:4377
bool is_game_over()
Definition: game.cpp:2691
void perhaps_add_random_npc()
Definition: game.cpp:11612
void mon_info_update()
Definition: game.cpp:4182
bool handle_action()
const T & obj() const
Definition: ammo_effect.cpp:26
void build_floor_caches()
Definition: map.cpp:8004
void process_falling()
Invoked drop_everything on cached dirty tiles.
Definition: map.cpp:2269
void emit_field(const tripoint &pos, const emit_id &src, float mul=1.0f)
Runs one cycle of emission src which may result in propagation of fields.
Definition: map_field.cpp:1928
const std::vector< tripoint > & get_furn_field_locations() const
Definition: map.cpp:7701
void spawn_monsters(bool ignore_sight)
Spawn monsters from submap spawn points and from the overmap.
Definition: map.cpp:7660
void vehmove()
Definition: map.cpp:410
void creature_in_field(Creature &critter)
Apply field effects to the creature when it's on a square with fields.
Definition: map_field.cpp:1563
void process_fields()
Definition: map_field.cpp:141
furn_id furn(const tripoint &p) const
Definition: map.cpp:1343
void build_map_cache(int zlev, bool skip_lightmap=false)
Definition: map.cpp:8170
void process_items()
Definition: map.cpp:4559
static void process_all()
Handles mission deadline processing.
Definition: mission.cpp:98
void set_scent(const tripoint_abs_omt &loc, int strength)
Method to set a scent trace.
void process_mongroups()
Process nearby monstergroups (dying mostly).
void move_hordes()
Let hordes move a step.
const activity_id & id() const
cata::optional< std::string > get_progress_message(const avatar &u) const
Helper that returns an activity specific progress message.
bool is_dead_state() const override
Returns true if the player should be dead.
Definition: player.cpp:819
int volume
Definition: player.h:642
int scent
Definition: player.h:651
void update_body_wetness(const w_point &weather)
Maintains body wetness and handles the rate at which the player dries.
Definition: player.cpp:1606
void process_turn() override
Resets movement points and applies other non-idempotent changes.
Definition: player.cpp:278
void set(const tripoint &p, int value, const scenttype_id &type=scenttype_id())
Get the scent value at the given position.
Definition: scent_map.cpp:102
void update(const tripoint &center, map &m)
Definition: scent_map.cpp:150
static constexpr time_duration from_minutes(const T m)
Definition: calendar.h:212
void process()
Process all queued events, potentially altering the game state and modifying the event queue.
static const activity_id ACT_AUTODRIVE("ACT_AUTODRIVE")
static const efftype_id effect_sleep("sleep")
@ QUIT_WATCH
Definition: game.h:73
static constexpr int MAX_VIEW_DISTANCE
void handle_weather_effects(const weather_type_id &w)
Definition: weather.cpp:522
bool once_every(const time_duration &event_frequency)
Predicate to handle rate-limiting.
Definition: calendar.cpp:490
explosion_queue & get_explosion_queue()
Definition: explosion.cpp:1170
void do_vehicle_engine_sfx()
Definition: sounds.cpp:1614
void do_hearing_loss(int turns=-1)
Definition: sounds.cpp:1609
void do_danger_music()
Definition: sounds.cpp:1613
void do_vehicle_exterior_engine_sfx()
Definition: sounds.cpp:1615
void do_fatigue()
Definition: sounds.cpp:1634
void remove_hearing_loss()
Definition: sounds.cpp:1610
void process_sound_markers(player *p)
Definition: sounds.cpp:386
void process_sounds()
Definition: sounds.cpp:304
void reset_markers()
Definition: sounds.cpp:572
vehicle * veh_pointer_or_null(const optional_vpart_position &p)

References _, ACT_AUTODRIVE, Character::action_taken(), Character::activity, add_artifact_dreams(), all_npcs(), Character::apply_wetness_morale(), autopilot_vehicles(), autosave(), map::build_floor_caches(), map::build_map_cache(), calc_driving_offset(), Character::check_and_recover_morale(), Character::check_mount_is_spooked(), cleanup_at_end(), cleanup_dead(), Character::controlling_vehicle, map::creature_in_field(), sfx::do_danger_music(), sfx::do_fatigue(), sfx::do_hearing_loss(), sfx::do_vehicle_engine_sfx(), sfx::do_vehicle_exterior_engine_sfx(), driving_view_offset, effect_sleep, map::emit_field(), explosion_handler::explosion_queue::execute(), first_redraw_since_waiting_started, time_duration::from_minutes(), map::furn(), gamemode, explosion_handler::get_explosion_queue(), map::get_furn_field_locations(), get_levz(), player_activity::get_progress_message(), Character::get_type_of_scent(), get_weather, Character::global_omt_location(), grid_tracker_ptr, handle_action(), vehicle::handle_potential_theft(), handle_weather_effects(), Character::has_active_bionic(), Character::has_destination(), Character::has_distant_destination(), Creature::has_effect(), Character::has_trait(), player_activity::id(), Character::in_vehicle, invalidate_main_ui_adaptor(), player::is_dead_state(), Character::is_deaf(), is_game_over(), Character::is_mounted(), Creature::is_underwater(), load_npcs(), m, MAX_VIEW_DISTANCE, mon_info_update(), monmove(), overmapbuffer::move_hordes(), Creature::moves, moves_since_last_save, new_game, npcs_dirty, int_id< T >::obj(), calendar::once_every(), overmap_buffer, overmap_npc_move(), perhaps_add_random_npc(), Character::pos(), game::debug_hour_timer::print_time(), timed_event_manager::process(), process_activity(), mission::process_all(), map::process_falling(), map::process_fields(), map::process_items(), overmapbuffer::process_mongroups(), sounds::process_sound_markers(), sounds::process_sounds(), player::process_turn(), process_voluntary_act_interrupt(), queue_screenshot, QUIT_WATCH, ui_manager::redraw(), refresh_display(), sfx::remove_hearing_loss(), reset_light_level(), sounds::reset_markers(), rl_dist(), scent, player::scent, scent_map::set(), overmapbuffer::set_scent(), map::spawn_monsters(), take_screenshot(), timed_events, calendar::turn, u, scent_map::update(), Character::update_body(), player::update_body_wetness(), Character::update_bodytemp(), Character::update_morale(), update_stair_monsters(), uquit, map::veh_at(), veh_pointer_or_null(), map::vehmove(), player::volume, wait_popup, point::x, and point::y.

◆ draw()

void game::draw ( )

Definition at line 3463 of file game.cpp.

3464{
3465 if( test_mode ) {
3466 return;
3467 }
3468
3469 //temporary fix for updating visibility for minimap
3470 ter_view_p.z = ( u.pos() + u.view_offset ).z;
3473
3474 werase( w_terrain );
3475 draw_ter();
3476 for( auto it = draw_callbacks.begin(); it != draw_callbacks.end(); ) {
3477 shared_ptr_fast<draw_callback_t> cb = it->lock();
3478 if( cb ) {
3479 ( *cb )();
3480 ++it;
3481 } else {
3482 it = draw_callbacks.erase( it );
3483 }
3484 }
3486
3487 draw_panels( true );
3488}
bool test_mode
Set to true when running in test mode (e.g.
tripoint ter_view_p
Definition: game.h:1034
void draw_panels(bool force_draw=false)
Definition: game.cpp:3490
void draw_ter(bool draw_sounds=true)
Definition: game.cpp:3604
void update_visibility_cache(int zlev)
Definition: map.cpp:5586
int z
Definition: point.h:152

References map::build_map_cache(), draw_callbacks, draw_panels(), draw_ter(), m, Character::pos(), ter_view_p, test_mode, u, map::update_visibility_cache(), player::view_offset, w_terrain, catacurses::werase(), catacurses::wnoutrefresh(), and tripoint::z.

◆ draw_below_override()

void game::draw_below_override ( const tripoint p,
bool  draw 
)

Definition at line 955 of file animation.cpp.

956{
957}

◆ draw_bullet()

void game::draw_bullet ( const tripoint t,
int  i,
const std::vector< tripoint > &  trajectory,
char  bullet 
)

Definition at line 510 of file animation.cpp.

512{
513 draw_bullet_curses( m, t, bullet, &trajectory[i] );
514}
void draw_bullet_curses(map &m, const tripoint &t, const char bullet, const tripoint *const p)
Definition: animation.cpp:451
std::vector< tripoint > trajectory
Definition: ranged.h:32

References anonymous_namespace{animation.cpp}::draw_bullet_curses(), and m.

◆ draw_critter()

void game::draw_critter ( const Creature critter,
const tripoint center 
)

Definition at line 3586 of file game.cpp.

3587{
3588 draw_critter_internal( w_terrain, critter, center, false, m, u );
3589}
static void draw_critter_internal(const catacurses::window &w, const Creature &critter, const tripoint &center, bool inverted, const map &m, const avatar &u)
Definition: game.cpp:3553

References center, draw_critter_internal(), m, u, and w_terrain.

Referenced by draw_ter().

◆ draw_critter_highlighted()

void game::draw_critter_highlighted ( const Creature critter,
const tripoint center 
)

Definition at line 3591 of file game.cpp.

3592{
3593 draw_critter_internal( w_terrain, critter, center, true, m, u );
3594}

References center, draw_critter_internal(), m, u, and w_terrain.

◆ draw_cursor()

void game::draw_cursor ( const tripoint p)

Definition at line 716 of file animation.cpp.

717{
718 const tripoint rp = relative_view_pos( *this, p );
719 mvwputch_inv( w_terrain, rp.xy(), c_light_green, 'X' );
720}
#define c_light_green
Definition: color.h:28
tripoint relative_view_pos(const game &g, const tripoint &p) noexcept
Definition: animation.cpp:119
void mvwputch_inv(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:491

References c_light_green, mvwputch_inv(), anonymous_namespace{animation.cpp}::relative_view_pos(), w_terrain, and tripoint::xy().

Referenced by draw_look_around_cursor().

◆ draw_field_override()

void game::draw_field_override ( const tripoint p,
const field_type_id id 
)

Definition at line 911 of file animation.cpp.

912{
913}

◆ draw_furniture_override()

void game::draw_furniture_override ( const tripoint p,
const furn_id id 
)

Definition at line 872 of file animation.cpp.

873{
874}

◆ draw_graffiti_override()

void game::draw_graffiti_override ( const tripoint p,
bool  has 
)

Definition at line 885 of file animation.cpp.

886{
887}

◆ draw_highlight()

void game::draw_highlight ( const tripoint p)

Definition at line 729 of file animation.cpp.

730{
731 // Do nothing
732}

◆ draw_hit_mon()

void game::draw_hit_mon ( const tripoint p,
const monster m,
bool  dead = false 
)

Definition at line 573 of file animation.cpp.

574{
575 draw_hit_mon_curses( p, m, u, dead );
576}
void draw_hit_mon_curses(const tripoint &center, const monster &m, const player &u, const bool dead)
Definition: animation.cpp:544

References dead, anonymous_namespace{animation.cpp}::draw_hit_mon_curses(), m, and u.

◆ draw_hit_player()

void game::draw_hit_player ( const Character p,
int  dam 
)

Definition at line 618 of file animation.cpp.

619{
620 draw_hit_player_curses( *this, p, dam );
621}
void draw_hit_player_curses(const game &g, const Character &p, const int dam)
Definition: animation.cpp:581

References anonymous_namespace{animation.cpp}::draw_hit_player_curses().

◆ draw_item_override()

void game::draw_item_override ( const tripoint p,
const itype_id id,
const mtype_id mid,
bool  hilite 
)

Definition at line 925 of file animation.cpp.

927{
928}

◆ draw_line() [1/2]

void game::draw_line ( const tripoint p,
const std::vector< tripoint > &  points 
)

Definition at line 702 of file animation.cpp.

703{
704 draw_line_curses( *this, points );
705}
void draw_line_curses(game &g, const std::vector< tripoint > &points)
Definition: animation.cpp:682

References anonymous_namespace{animation.cpp}::draw_line_curses().

◆ draw_line() [2/2]

void game::draw_line ( const tripoint p,
const tripoint center_point,
const std::vector< tripoint > &  points,
bool  noreveal = false 
)

Definition at line 669 of file animation.cpp.

671{
672 if( !u.sees( p ) ) {
673 return;
674 }
675
676 draw_line_curses( *this, center, points, noreveal );
677}

References center, anonymous_namespace{animation.cpp}::draw_line_curses(), Character::sees(), and u.

Referenced by draw_ter().

◆ draw_look_around_cursor()

void game::draw_look_around_cursor ( const tripoint lp,
const visibility_variables cache 
)

Definition at line 5973 of file game.cpp.

5974{
5975 if( !liveview.is_enabled() ) {
5976#if defined( TILES )
5977 if( is_draw_tiles_mode() ) {
5978 draw_cursor( lp );
5979 return;
5980 }
5981#endif
5982 const tripoint view_center = u.pos() + u.view_offset;
5983 visibility_type visibility = VIS_HIDDEN;
5984 const bool inbounds = m.inbounds( lp );
5985 if( inbounds ) {
5986 visibility = m.get_visibility( m.apparent_light_at( lp, cache ), cache );
5987 }
5988 if( visibility == VIS_CLEAR ) {
5989 const Creature *const creature = critter_at( lp, true );
5990 if( creature != nullptr && u.sees( *creature ) ) {
5991 creature->draw( w_terrain, view_center, true );
5992 } else {
5993 m.drawsq( w_terrain, lp, drawsq_params().highlight( true ).center( view_center ) );
5994 }
5995 } else {
5996 std::string visibility_indicator;
5997 nc_color visibility_indicator_color = c_white;
5998 switch( visibility ) {
5999 case VIS_CLEAR:
6000 // Already handled by the outer if statement
6001 break;
6002 case VIS_BOOMER:
6003 case VIS_BOOMER_DARK:
6004 visibility_indicator = '#';
6005 visibility_indicator_color = c_pink;
6006 break;
6007 case VIS_DARK:
6008 visibility_indicator = '#';
6009 visibility_indicator_color = c_dark_gray;
6010 break;
6011 case VIS_LIT:
6012 visibility_indicator = '#';
6013 visibility_indicator_color = c_light_gray;
6014 break;
6015 case VIS_HIDDEN:
6016 visibility_indicator = 'x';
6017 visibility_indicator_color = c_white;
6018 break;
6019 }
6020
6021 const tripoint screen_pos = point( POSX, POSY ) + lp - view_center;
6022 mvwputch( w_terrain, screen_pos.xy(), visibility_indicator_color, visibility_indicator );
6023 }
6024 }
6025}
void draw_cursor(const tripoint &p)
Definition: animation.cpp:716
T * critter_at(const tripoint &p, bool allow_hallucination=false)
Returns the Creature at the given location.
Definition: game.cpp:4856
bool is_enabled()
Definition: live_view.cpp:75
virtual bool inbounds(const tripoint &p) const
Definition: map.cpp:7711
visibility_type get_visibility(lit_level ll, const visibility_variables &cache) const
Definition: map.cpp:5632
lit_level apparent_light_at(const tripoint &p, const visibility_variables &cache) const
Determine the visible light level for a tile, based on light_at for the tile, vision distance,...
Definition: lightmap.cpp:700
void drawsq(const catacurses::window &w, const tripoint &p, const drawsq_params &params) const
Draw the map tile at the given coordinate.
Definition: map.cpp:5810
#define c_dark_gray
Definition: color.h:20
#define c_pink
Definition: color.h:31
visibility_type
Definition: enums.h:57
@ VIS_CLEAR
Definition: enums.h:59
@ VIS_BOOMER
Definition: enums.h:61
@ VIS_DARK
Definition: enums.h:62
@ VIS_BOOMER_DARK
Definition: enums.h:63
@ VIS_HIDDEN
Definition: enums.h:58
@ VIS_LIT
Definition: enums.h:60
bool is_draw_tiles_mode()
Check whether we're in tile drawing mode.
Definition: output.cpp:2029
Draw parameters used by map::drawsq() and similar methods.
Definition: map.h:176

References map::apparent_light_at(), c_dark_gray, c_light_gray, c_pink, c_white, center, creature, critter_at(), draw_cursor(), map::drawsq(), map::get_visibility(), map::inbounds(), is_draw_tiles_mode(), live_view::is_enabled(), liveview, m, mvwputch(), Character::pos(), POSX, POSY, Character::sees(), u, player::view_offset, VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, w_terrain, and tripoint::xy().

Referenced by look_around().

◆ draw_minimap()

void game::draw_minimap ( )
private

Definition at line 3664 of file game.cpp.

3665{
3666
3667 // Draw the box
3668 werase( w_minimap );
3670
3671 const tripoint_abs_omt curs = u.global_omt_location();
3672 const point_abs_omt curs2( curs.xy() );
3674 bool drew_mission = targ == overmap::invalid_tripoint;
3675
3676 for( int i = -2; i <= 2; i++ ) {
3677 for( int j = -2; j <= 2; j++ ) {
3678 const point_abs_omt om( curs2 + point( i, j ) );
3679 nc_color ter_color;
3680 tripoint_abs_omt omp( om, get_levz() );
3681 std::string ter_sym;
3682 const bool seen = overmap_buffer.seen( omp );
3683 const bool vehicle_here = overmap_buffer.has_vehicle( omp );
3684 if( overmap_buffer.has_note( omp ) ) {
3685
3686 const std::string &note_text = overmap_buffer.note( omp );
3687
3688 ter_color = c_yellow;
3689 ter_sym = "N";
3690
3691 int symbolIndex = note_text.find( ':' );
3692 int colorIndex = note_text.find( ';' );
3693
3694 bool symbolFirst = symbolIndex < colorIndex;
3695
3696 if( colorIndex > -1 && symbolIndex > -1 ) {
3697 if( symbolFirst ) {
3698 if( colorIndex > 4 ) {
3699 colorIndex = -1;
3700 }
3701 if( symbolIndex > 1 ) {
3702 symbolIndex = -1;
3703 colorIndex = -1;
3704 }
3705 } else {
3706 if( symbolIndex > 4 ) {
3707 symbolIndex = -1;
3708 }
3709 if( colorIndex > 2 ) {
3710 colorIndex = -1;
3711 }
3712 }
3713 } else if( colorIndex > 2 ) {
3714 colorIndex = -1;
3715 } else if( symbolIndex > 1 ) {
3716 symbolIndex = -1;
3717 }
3718
3719 if( symbolIndex > -1 ) {
3720 int symbolStart = 0;
3721 if( colorIndex > -1 && !symbolFirst ) {
3722 symbolStart = colorIndex + 1;
3723 }
3724 ter_sym = note_text.substr( symbolStart, symbolIndex - symbolStart ).c_str()[0];
3725 }
3726
3727 if( colorIndex > -1 ) {
3728
3729 int colorStart = 0;
3730
3731 if( symbolIndex > -1 && symbolFirst ) {
3732 colorStart = symbolIndex + 1;
3733 }
3734
3735 std::string sym = note_text.substr( colorStart, colorIndex - colorStart );
3736
3737 if( sym.length() == 2 ) {
3738 if( sym == "br" ) {
3739 ter_color = c_brown;
3740 } else if( sym == "lg" ) {
3741 ter_color = c_light_gray;
3742 } else if( sym == "dg" ) {
3743 ter_color = c_dark_gray;
3744 }
3745 } else {
3746 char colorID = sym.c_str()[0];
3747 if( colorID == 'r' ) {
3748 ter_color = c_light_red;
3749 } else if( colorID == 'R' ) {
3750 ter_color = c_red;
3751 } else if( colorID == 'g' ) {
3752 ter_color = c_light_green;
3753 } else if( colorID == 'G' ) {
3754 ter_color = c_green;
3755 } else if( colorID == 'b' ) {
3756 ter_color = c_light_blue;
3757 } else if( colorID == 'B' ) {
3758 ter_color = c_blue;
3759 } else if( colorID == 'W' ) {
3760 ter_color = c_white;
3761 } else if( colorID == 'C' ) {
3762 ter_color = c_cyan;
3763 } else if( colorID == 'c' ) {
3764 ter_color = c_light_cyan;
3765 } else if( colorID == 'P' ) {
3766 ter_color = c_pink;
3767 } else if( colorID == 'm' ) {
3768 ter_color = c_magenta;
3769 }
3770 }
3771 }
3772 } else if( !seen ) {
3773 ter_sym = " ";
3774 ter_color = c_black;
3775 } else if( vehicle_here ) {
3776 ter_color = c_cyan;
3777 ter_sym = "c";
3778 } else {
3779 const oter_id &cur_ter = overmap_buffer.ter( omp );
3780 ter_sym = cur_ter->get_symbol();
3781 if( overmap_buffer.is_explored( omp ) ) {
3782 ter_color = c_dark_gray;
3783 } else {
3784 ter_color = cur_ter->get_color();
3785 }
3786 }
3787 if( !drew_mission && targ.xy() == omp.xy() ) {
3788 // If there is a mission target, and it's not on the same
3789 // overmap terrain as the player character, mark it.
3790 // TODO: Inform player if the mission is above or below
3791 drew_mission = true;
3792 if( i != 0 || j != 0 ) {
3793 ter_color = red_background( ter_color );
3794 }
3795 }
3796 if( i == 0 && j == 0 ) {
3797 mvwputch_hi( w_minimap, point( 3, 3 ), ter_color, ter_sym );
3798 } else {
3799 mvwputch( w_minimap, point( 3 + i, 3 + j ), ter_color, ter_sym );
3800 }
3801 }
3802 }
3803
3804 // Print arrow to mission if we have one!
3805 if( !drew_mission ) {
3806 double slope = curs2.x() != targ.x() ?
3807 static_cast<double>( targ.y() - curs2.y() ) / ( targ.x() - curs2.x() ) : 4;
3808
3809 if( curs2.x() == targ.x() || std::fabs( slope ) > 3.5 ) { // Vertical slope
3810 if( targ.y() > curs2.y() ) {
3811 mvwputch( w_minimap, point( 3, 6 ), c_red, "*" );
3812 } else {
3813 mvwputch( w_minimap, point( 3, 0 ), c_red, "*" );
3814 }
3815 } else {
3816 int arrowx = -1;
3817 int arrowy = -1;
3818 if( std::fabs( slope ) >= 1. ) { // y diff is bigger!
3819 arrowy = targ.y() > curs2.y() ? 6 : 0;
3820 arrowx =
3821 static_cast<int>( 3 + 3 * ( targ.y() > curs2.y() ? slope : ( 0 - slope ) ) );
3822 if( arrowx < 0 ) {
3823 arrowx = 0;
3824 }
3825 if( arrowx > 6 ) {
3826 arrowx = 6;
3827 }
3828 } else {
3829 arrowx = targ.x() > curs2.x() ? 6 : 0;
3830 arrowy = static_cast<int>( 3 + 3 * ( targ.x() > curs2.x() ? slope : -slope ) );
3831 if( arrowy < 0 ) {
3832 arrowy = 0;
3833 }
3834 if( arrowy > 6 ) {
3835 arrowy = 6;
3836 }
3837 }
3838 char glyph = '*';
3839 if( targ.z() > u.posz() ) {
3840 glyph = '^';
3841 } else if( targ.z() < u.posz() ) {
3842 glyph = 'v';
3843 }
3844
3845 mvwputch( w_minimap, point( arrowx, arrowy ), c_red, glyph );
3846 }
3847 }
3848
3849 const int sight_points = g->u.overmap_sight_range( g->light_level( g->u.posz() ) );
3850 for( int i = -3; i <= 3; i++ ) {
3851 for( int j = -3; j <= 3; j++ ) {
3852 if( i > -3 && i < 3 && j > -3 && j < 3 ) {
3853 continue; // only do hordes on the border, skip inner map
3854 }
3855 const tripoint_abs_omt omp( curs2 + point( i, j ), get_levz() );
3857 if( overmap_buffer.seen( omp )
3858 && g->u.overmap_los( omp, sight_points ) ) {
3859 mvwputch( w_minimap, point( i + 3, j + 3 ), c_green,
3860 overmap_buffer.get_horde_size( omp ) > HORDE_VISIBILITY_SIZE * 2 ? 'Z' : 'z' );
3861 }
3862 }
3863 }
3864 }
3865
3867}
tripoint_abs_omt get_active_mission_target() const
Returns the target of the active mission or overmap::invalid_tripoint if there is no active mission.
Definition: avatar.cpp:198
constexpr auto & x()
Definition: coordinates.h:118
constexpr auto & z()
Definition: coordinates.h:133
constexpr auto & y()
Definition: coordinates.h:124
constexpr auto xy() const
Definition: coordinates.h:130
static constexpr tripoint_abs_omt invalid_tripoint
Dummy value, used to indicate that a point returned by a function is invalid.
Definition: overmap.h:260
bool seen(const tripoint_abs_omt &p)
const std::string & note(const tripoint_abs_omt &p)
int get_horde_size(const tripoint_abs_omt &p)
bool is_explored(const tripoint_abs_omt &p)
const oter_id & ter(const tripoint_abs_omt &p)
Returns the overmap terrain at the given OMT coordinates.
bool has_note(const tripoint_abs_omt &p)
Uses global overmap terrain coordinates.
bool has_vehicle(const tripoint_abs_omt &p)
nc_color red_background(const nc_color &c)
Definition: color.cpp:515
#define c_blue
Definition: color.h:23
#define c_black
Definition: color.h:17
#define c_light_blue
Definition: color.h:29
#define c_yellow
Definition: color.h:32
#define c_light_cyan
Definition: color.h:30
#define c_cyan
Definition: color.h:24
#define c_light_red
Definition: color.h:27
static constexpr int HORDE_VISIBILITY_SIZE
constexpr scale om
Definition: coordinates.h:34
void mvwputch_hi(const catacurses::window &w, const point &p, nc_color FG, int ch)
Definition: output.cpp:508
std::string get_symbol(const bool from_land_use_code=false) const
Definition: omdata.h:209
nc_color get_color(const bool from_land_use_code=false) const
Definition: omdata.h:217

References c_black, c_blue, c_brown, c_cyan, c_dark_gray, c_green, c_light_blue, c_light_cyan, c_light_gray, c_light_green, c_light_red, c_magenta, c_pink, c_red, c_white, c_yellow, draw_border(), units::fabs(), g, avatar::get_active_mission_target(), oter_t::get_color(), overmapbuffer::get_horde_size(), get_levz(), oter_t::get_symbol(), Character::global_omt_location(), overmapbuffer::has_note(), overmapbuffer::has_vehicle(), HORDE_VISIBILITY_SIZE, overmap::invalid_tripoint, overmapbuffer::is_explored(), mvwputch(), mvwputch_hi(), overmapbuffer::note(), coords::om, overmap_buffer, Character::posz(), red_background(), overmapbuffer::seen(), overmapbuffer::ter(), u, w_minimap, catacurses::werase(), catacurses::wnoutrefresh(), coords::coord_point< Point, Origin, Scale >::x(), coords::coord_point< Point, Origin, Scale >::xy(), coords::coord_point< Point, Origin, Scale >::y(), and coords::coord_point< Point, Origin, Scale >::z().

◆ draw_monster_override()

void game::draw_monster_override ( const tripoint p,
const mtype_id id,
int  count,
bool  more,
Creature::Attitude  att 
)

Definition at line 969 of file animation.cpp.

971{
972}

◆ draw_panels()

void game::draw_panels ( bool  force_draw = false)

Definition at line 3490 of file game.cpp.

3491{
3492 static int previous_turn = -1;
3493 const int current_turn = to_turns<int>( calendar::turn - calendar::turn_zero );
3494 const bool draw_this_turn = current_turn > previous_turn || force_draw;
3495 auto &mgr = panel_manager::get_manager();
3496 int y = 0;
3497 const bool sidebar_right = get_option<std::string>( "SIDEBAR_POSITION" ) == "right";
3498 int spacer = get_option<bool>( "SIDEBAR_SPACERS" ) ? 1 : 0;
3499 int log_height = 0;
3500 for( const window_panel &panel : mgr.get_current_layout() ) {
3501 if( panel.get_height() != -2 && panel.toggle && panel.render() ) {
3502 log_height += panel.get_height() + spacer;
3503 }
3504 }
3505 log_height = std::max( TERMY - log_height, 3 );
3506 for( const window_panel &panel : mgr.get_current_layout() ) {
3507 if( panel.render() ) {
3508 // height clamped to window height.
3509 int h = std::min( panel.get_height(), TERMY - y );
3510 if( h == -2 ) {
3511 h = log_height;
3512 }
3513 h += spacer;
3514 if( panel.toggle && panel.render() && h > 0 ) {
3515 if( panel.always_draw || draw_this_turn ) {
3516 panel.draw( u, catacurses::newwin( h, panel.get_width(),
3517 point( sidebar_right ? TERMX - panel.get_width() : 0, y ) ) );
3518 }
3519 if( show_panel_adm ) {
3520 const std::string panel_name = _( panel.get_name() );
3521 const int panel_name_width = utf8_width( panel_name );
3522 auto label = catacurses::newwin( 1, panel_name_width, point( sidebar_right ?
3523 TERMX - panel.get_width() - panel_name_width - 1 : panel.get_width() + 1, y ) );
3524 werase( label );
3525 mvwprintz( label, point_zero, c_light_red, panel_name );
3527 label = catacurses::newwin( h, 1,
3528 point( sidebar_right ? TERMX - panel.get_width() - 1 : panel.get_width(), y ) );
3529 werase( label );
3530 if( h == 1 ) {
3532 } else {
3534 for( int i = 1; i < h - 1; i++ ) {
3536 }
3537 mvwputch( label, point( 0, h - 1 ), c_light_red, sidebar_right ? LINE_XXOO : LINE_XOOX );
3538 }
3540 }
3541 y += h;
3542 }
3543 }
3544 }
3545 previous_turn = current_turn;
3546}
bool show_panel_adm
Definition: game.h:1062
const time_point turn_zero
Represents time point 0.
Definition: calendar.cpp:26
#define LINE_XOXO
Definition: output.h:39
#define LINE_OXOX
Definition: output.h:40
#define LINE_OXXX
Definition: output.h:48
#define LINE_XOOX
Definition: output.h:44
#define LINE_XXOO
Definition: output.h:41
Struct used for storing labels (easier to json opposed to a std::map<point, std::string>)
Definition: vehicle.h:578

References _, c_light_red, panel_manager::get_manager(), LINE_OXOX, LINE_OXXX, LINE_XOOX, LINE_XOXO, LINE_XXOO, mvwprintz(), mvwputch(), catacurses::newwin(), point_zero, show_panel_adm, TERMX, TERMY, calendar::turn, calendar::turn_zero, u, utf8_width(), catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by draw().

◆ draw_pixel_minimap()

void game::draw_pixel_minimap ( const catacurses::window w)

Definition at line 3548 of file game.cpp.

3549{
3550 w_pixel_minimap = w;
3551}

References w_pixel_minimap.

◆ draw_radiation_override()

void game::draw_radiation_override ( const tripoint p,
int  rad 
)

Definition at line 846 of file animation.cpp.

847{
848}

◆ draw_sct()

void game::draw_sct ( )

Definition at line 797 of file animation.cpp.

798{
799 draw_sct_curses( *this );
800}
void draw_sct_curses(const game &g)
Definition: animation.cpp:764

References anonymous_namespace{animation.cpp}::draw_sct_curses().

Referenced by get_player_input().

◆ draw_ter() [1/2]

void game::draw_ter ( bool  draw_sounds = true)

Definition at line 3604 of file game.cpp.

3605{
3607 draw_sounds );
3608}
bool is_looking
Definition: game.h:250

References draw_ter(), is_looking, Character::pos(), u, and player::view_offset.

Referenced by draw(), and draw_ter().

◆ draw_ter() [2/2]

void game::draw_ter ( const tripoint center,
bool  looking = false,
bool  draw_sounds = true 
)

Definition at line 3610 of file game.cpp.

3611{
3613
3614 m.draw( w_terrain, center );
3615
3616 if( draw_sounds ) {
3618 }
3619
3620 for( Creature &critter : all_creatures() ) {
3621 draw_critter( critter, center );
3622 }
3623
3624 if( !destination_preview.empty() && u.view_offset.z == 0 ) {
3625 // Draw auto-move preview trail
3626 const tripoint &final_destination = destination_preview.back();
3627 tripoint line_center = u.pos() + u.view_offset;
3628 draw_line( final_destination, line_center, destination_preview, true );
3629 mvwputch( w_terrain, final_destination.xy() - u.view_offset.xy() + point( POSX - u.posx(),
3630 POSY - u.posy() ), c_white, 'X' );
3631 }
3632
3633 if( u.controlling_vehicle && !looking ) {
3634 draw_veh_dir_indicator( false );
3635 draw_veh_dir_indicator( true );
3636 }
3637 // Place the cursor over the player as is expected by screen readers.
3638 wmove( w_terrain, -center.xy() + g->u.pos().xy() + point( POSX, POSY ) );
3639}
int posx() const override
Definition: character.h:781
int posy() const override
Definition: character.h:784
void draw_critter(const Creature &critter, const tripoint &center)
Definition: game.cpp:3586
Creature_range all_creatures()
Returns an anonymous range that contains all creatures.
Definition: game.cpp:12544
std::vector< tripoint > destination_preview
Definition: game.h:1114
void draw_veh_dir_indicator(bool next)
Definition: game.cpp:3656
void draw_line(const tripoint &p, const tripoint &center_point, const std::vector< tripoint > &points, bool noreveal=false)
Definition: animation.cpp:669
void draw(const catacurses::window &w, const tripoint &center)
Draw a visible part of the map into w.
Definition: map.cpp:5682
static void draw_footsteps(const catacurses::window &window, const tripoint &offset)
Definition: game.cpp:3276
void wmove(const window &win, const point &p)
Definition: ncurses_def.cpp:98

References all_creatures(), c_white, center, Character::controlling_vehicle, destination_preview, map::draw(), draw_critter(), draw_footsteps(), draw_line(), draw_veh_dir_indicator(), g, m, mvwputch(), Character::pos(), Character::posx(), POSX, Character::posy(), POSY, ter_view_p, u, player::view_offset, w_terrain, catacurses::wmove(), tripoint::xy(), and tripoint::z.

◆ draw_terrain_override()

void game::draw_terrain_override ( const tripoint p,
const ter_id id 
)

Definition at line 859 of file animation.cpp.

860{
861}

◆ draw_trail_to_square()

void game::draw_trail_to_square ( const tripoint t,
bool  bDrawX 
)

Definition at line 7276 of file game.cpp.

7277{
7278 ::draw_trail( u.pos(), u.pos() + t, bDrawX );
7279}
static void draw_trail(const tripoint &start, const tripoint &end, bool bDrawX)
Definition: game.cpp:7246

References draw_trail(), Character::pos(), and u.

◆ draw_trap_override()

void game::draw_trap_override ( const tripoint p,
const trap_id id 
)

Definition at line 898 of file animation.cpp.

899{
900}

◆ draw_veh_dir_indicator()

void game::draw_veh_dir_indicator ( bool  next)

Definition at line 3656 of file game.cpp.

3657{
3658 if( const cata::optional<tripoint> indicator_offset = get_veh_dir_indicator_location( next ) ) {
3659 auto col = next ? c_white : c_dark_gray;
3660 mvwputch( w_terrain, indicator_offset->xy() - u.view_offset.xy() + point( POSX, POSY ), col, 'X' );
3661 }
3662}
cata::optional< tripoint > get_veh_dir_indicator_location(bool next) const
Returns the location where the indicator should go relative to the reality bubble,...
Definition: game.cpp:3641

References c_dark_gray, c_white, get_veh_dir_indicator_location(), mvwputch(), POSX, POSY, u, player::view_offset, w_terrain, and tripoint::xy().

Referenced by draw_ter().

◆ draw_vpart_override()

void game::draw_vpart_override ( const tripoint p,
const vpart_id id,
int  part_mod,
units::angle  veh_dir,
bool  hilite,
const point mount 
)

Definition at line 941 of file animation.cpp.

943{
944}

◆ draw_weather()

void game::draw_weather ( const weather_printable wPrint)

Definition at line 756 of file animation.cpp.

757{
759}
void draw_weather_curses(const catacurses::window &win, const weather_printable &w)
Definition: animation.cpp:737

References anonymous_namespace{animation.cpp}::draw_weather_curses(), and w_terrain.

Referenced by get_player_input().

◆ draw_zones()

void game::draw_zones ( const tripoint start,
const tripoint end,
const tripoint offset 
)

Definition at line 832 of file animation.cpp.

833{
834 draw_zones_curses( w_terrain, start, end, offset );
835}
void draw_zones_curses(const catacurses::window &w, const tripoint &start, const tripoint &end, const tripoint &offset)
Definition: animation.cpp:805

References anonymous_namespace{animation.cpp}::draw_zones_curses(), and w_terrain.

◆ drop()

void game::drop ( )
private

Definition at line 8318 of file game.cpp.

8319{
8321}
void drop(item_location loc, const tripoint &where)
Drops an item to the specified location.
Definition: character.cpp:2508
drop_locations multidrop(player &p)
Select items to drop.

References Character::drop(), game_menus::inv::multidrop(), Character::pos(), and u.

Referenced by handle_action().

◆ drop_in_direction()

void game::drop_in_direction ( )
private

Definition at line 8323 of file game.cpp.

8324{
8325 if( const cata::optional<tripoint> pnt = choose_adjacent( _( "Drop where?" ) ) ) {
8326 u.drop( game_menus::inv::multidrop( u ), *pnt );
8327 }
8328}

References _, choose_adjacent(), Character::drop(), game_menus::inv::multidrop(), and u.

Referenced by handle_action().

◆ dump_stats()

bool game::dump_stats ( const std::string &  what,
dump_mode  mode,
const std::vector< std::string > &  opts 
)

write statistics to stdout and

Returns
true if successful

Definition at line 37 of file dump.cpp.

39{
40 try {
41 loading_ui ui( false );
43 load_packs( _( "Loading content packs" ), { mod_id( "dda" ) }, ui );
45 } catch( const std::exception &err ) {
46 std::cerr << "Error loading data from json: " << err.what() << std::endl;
47 return false;
48 }
49
50 std::vector<std::string> header;
51 std::vector<std::vector<std::string>> rows;
52
53 int scol = 0; // sorting column
54
55 std::map<std::string, standard_npc> test_npcs;
56 test_npcs[ "S1" ] = standard_npc( "S1", { 0, 0, 2 }, { "gloves_survivor", "mask_lsurvivor" },
57 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
58 test_npcs[ "S2" ] = standard_npc( "S2", { 0, 0, 3 }, { "gloves_fingerless", "sunglasses" },
59 4, 8, 8, 8, 10 /* PER 10 */ );
60 test_npcs[ "S3" ] = standard_npc( "S3", { 0, 0, 4 }, { "gloves_plate", "helmet_plate" },
61 4, 10, 8, 8, 8 /* STAT 10 */ );
62 test_npcs[ "S4" ] = standard_npc( "S4", { 0, 0, 5 }, {}, 0, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
63 test_npcs[ "S5" ] = standard_npc( "S5", { 0, 0, 6 }, {}, 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
64 test_npcs[ "S6" ] = standard_npc( "S6", { 0, 0, 7 }, { "gloves_hsurvivor", "mask_hsurvivor" },
65 4, 8, 10, 8, 10 /* DEX 10, PER 10 */ );
66
67 std::map<std::string, item> test_items;
68 test_items[ "G1" ] = item( "glock_19" ).ammo_set( itype_id( "9mm" ) );
69 test_items[ "G2" ] = item( "hk_mp5" ).ammo_set( itype_id( "9mm" ) );
70 test_items[ "G3" ] = item( "ar15" ).ammo_set( itype_id( "223" ) );
71 test_items[ "G4" ] = item( "remington_700" ).ammo_set( itype_id( "270" ) );
72 test_items[ "G4" ].put_in( item( "rifle_scope" ) );
73
74 if( what == "AMMO" ) {
75 header = {
76 "Name", "Ammo", "Volume", "Weight", "Stack",
77 "Range", "Dispersion", "Recoil", "Damage", "Pierce", "Damage multiplier"
78 };
79 auto dump = [&rows]( const item & obj ) {
80 std::vector<std::string> r;
81 r.push_back( obj.tname( 1, false ) );
82 r.push_back( obj.ammo_type().str() );
83 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
84 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
85 r.push_back( std::to_string( obj.type->stack_size ) );
86 r.push_back( std::to_string( obj.type->ammo->range ) );
87 r.push_back( std::to_string( obj.type->ammo->dispersion ) );
88 r.push_back( std::to_string( obj.type->ammo->recoil ) );
89 damage_instance damage = obj.type->ammo->damage;
90 r.push_back( std::to_string( damage.total_damage() ) );
91 r.push_back( std::to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
92 rows.push_back( r );
93 };
94 for( const itype *e : item_controller->all() ) {
95 if( e->ammo ) {
96 dump( item( e, calendar::turn, item::solitary_tag {} ) );
97 }
98 }
99
100 } else if( what == "ARMOR" ) {
101 header = {
102 "Name", "Encumber (fit)", "Warmth", "Weight", "Storage", "Coverage", "Bash", "Cut", "Bullet", "Acid", "Fire"
103 };
104 auto dump = [&rows]( const item & obj ) {
105 std::vector<std::string> r;
106 r.push_back( obj.tname( 1, false ) );
107 r.push_back( std::to_string( obj.get_encumber( g->u ) ) );
108 r.push_back( std::to_string( obj.get_warmth() ) );
109 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
110 r.push_back( std::to_string( obj.get_storage() / units::legacy_volume_factor ) );
111 r.push_back( std::to_string( obj.get_coverage() ) );
112 r.push_back( std::to_string( obj.bash_resist() ) );
113 r.push_back( std::to_string( obj.cut_resist() ) );
114 r.push_back( std::to_string( obj.bullet_resist() ) );
115 r.push_back( std::to_string( obj.acid_resist() ) );
116 r.push_back( std::to_string( obj.fire_resist() ) );
117 rows.push_back( r );
118 };
119
120 body_part bp = opts.empty() ? num_bp : get_body_part_token( opts.front() );
121
122 for( const itype *e : item_controller->all() ) {
123 if( e->armor ) {
124 item obj( e );
125 if( bp == num_bp || obj.covers( bp ) ) {
126 if( obj.has_flag( flag_VARSIZE ) ) {
127 obj.set_flag( "FIT" );
128 }
129 dump( obj );
130 }
131 }
132 }
133
134 } else if( what == "EDIBLE" ) {
135 header = {
136 "Name", "Volume", "Weight", "Stack", "Calories", "Quench", "Healthy"
137 };
138 for( const auto &v : vitamin::all() ) {
139 header.push_back( v.second.name() );
140 }
141 auto dump = [&rows]( const item & obj ) {
142 std::vector<std::string> r;
143 r.push_back( obj.tname( 1, false ) );
144 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
145 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
146 r.push_back( std::to_string( obj.type->stack_size ) );
147 r.push_back( std::to_string( obj.get_comestible()->default_nutrition.kcal ) );
148 r.push_back( std::to_string( obj.get_comestible()->quench ) );
149 r.push_back( std::to_string( obj.get_comestible()->healthy ) );
150 auto vits = obj.get_comestible()->default_nutrition.vitamins;
151 for( const auto &v : vitamin::all() ) {
152 r.push_back( std::to_string( vits[ v.first ] ) );
153 }
154 rows.push_back( r );
155 };
156
157 for( const itype *e : item_controller->all() ) {
159
160 if( food.is_food() && g->u.can_eat( food ).success() ) {
161 dump( food );
162 }
163 }
164
165 } else if( what == "GUN" ) {
166 header = {
167 "Name", "Ammo", "Volume", "Weight", "Capacity",
168 "Range", "Dispersion", "Effective recoil", "Damage", "Pierce",
169 "Aim time", "Effective range", "Snapshot range", "Max range"
170 };
171
172 std::set<std::string> locations;
173 for( const itype *e : item_controller->all() ) {
174 if( e->gun ) {
175 std::transform( e->gun->valid_mod_locations.begin(),
176 e->gun->valid_mod_locations.end(),
177 std::inserter( locations, locations.begin() ),
178 []( const std::pair<gunmod_location, int> &q ) {
179 return q.first.name();
180 } );
181 }
182 }
183 for( const auto &e : locations ) {
184 header.push_back( e );
185 }
186
187 auto dump = [&rows, &locations]( const standard_npc & who, const item & obj ) {
188 std::vector<std::string> r;
189 r.push_back( obj.tname( 1, false ) );
190 r.push_back( !obj.ammo_types().empty() ? enumerate_as_string( obj.ammo_types().begin(),
191 obj.ammo_types().end(), []( const ammotype & at ) {
192 return at.str();
194 r.push_back( std::to_string( obj.volume() / units::legacy_volume_factor ) );
195 r.push_back( std::to_string( to_gram( obj.weight() ) ) );
196 r.push_back( std::to_string( obj.ammo_capacity() ) );
197 r.push_back( std::to_string( obj.gun_range() ) );
198 r.push_back( std::to_string( obj.gun_dispersion() ) );
199 r.push_back( std::to_string( obj.gun_recoil() ) );
200 damage_instance damage = obj.gun_damage();
201 r.push_back( std::to_string( damage.total_damage() ) );
202 r.push_back( std::to_string( damage.empty() ? 0 : ( *damage.begin() ).res_pen ) );
203
204 r.push_back( std::to_string( who.gun_engagement_moves( obj ) ) );
205
206 for( const auto &e : locations ) {
207 const auto &vml = obj.type->gun->valid_mod_locations;
208 const auto iter = vml.find( e );
209 r.push_back( std::to_string( iter != vml.end() ? iter->second : 0 ) );
210 }
211 rows.push_back( r );
212 };
213 for( const itype *e : item_controller->all() ) {
214 if( e->gun ) {
215 item gun( e );
216 if( !gun.magazine_integral() ) {
217 gun.put_in( item( gun.magazine_default() ) );
218 }
219 gun.ammo_set( gun.ammo_default( false ), gun.ammo_capacity() );
220
221 dump( test_npcs[ "S1" ], gun );
222
223 if( gun.type->gun->barrel_length > 0_ml ) {
224 gun.put_in( item( "barrel_small" ) );
225 dump( test_npcs[ "S1" ], gun );
226 }
227 }
228 }
229
230 } else if( what == "RECIPE" ) {
231
232 // optionally filter recipes to include only those using specified skills
233 recipe_subset dict;
234 for( const auto &r : recipe_dict ) {
235 if( opts.empty() || std::any_of( opts.begin(), opts.end(), [&r]( const std::string & s ) {
236 if( r.second.skill_used == skill_id( s ) && r.second.difficulty > 0 ) {
237 return true;
238 }
239 const auto iter = r.second.required_skills.find( skill_id( s ) );
240 return iter != r.second.required_skills.end() && iter->second > 0;
241 } ) ) {
242 dict.include( &r.second );
243 }
244 }
245
246 // only consider skills that are required by at least one recipe
247 std::vector<Skill> sk;
248 std::copy_if( Skill::skills.begin(), Skill::skills.end(),
249 std::back_inserter( sk ), [&dict]( const Skill & s ) {
250 return std::any_of( dict.begin(), dict.end(), [&s]( const recipe * r ) {
251 return r->skill_used == s.ident() ||
252 r->required_skills.find( s.ident() ) != r->required_skills.end();
253 } );
254 } );
255
256 header = { "Result" };
257
258 for( const auto &e : sk ) {
259 header.push_back( e.ident().str() );
260 }
261
262 for( const recipe *e : dict ) {
263 std::vector<std::string> r;
264 r.push_back( e->result_name() );
265 for( const auto &s : sk ) {
266 if( e->skill_used == s.ident() ) {
267 r.push_back( std::to_string( e->difficulty ) );
268 } else {
269 auto iter = e->required_skills.find( s.ident() );
270 r.push_back( std::to_string( iter != e->required_skills.end() ? iter->second : 0 ) );
271 }
272 }
273 rows.push_back( r );
274 }
275
276 } else if( what == "VEHICLE" ) {
277 header = {
278 "Name", "Weight (empty)", "Weight (fueled)",
279 "Max velocity (mph)", "Safe velocity (mph)", "Acceleration (mph/turn)",
280 "Aerodynamics coeff", "Rolling coeff", "Static Drag", "Offroad %"
281 };
282 auto dump = [&rows]( const vproto_id & obj ) {
283 vehicle veh_empty( obj, 0, 0 );
284 vehicle veh_fueled( obj, 100, 0 );
285
286 std::vector<std::string> r;
287 r.push_back( veh_empty.name );
288 r.push_back( std::to_string( to_kilogram( veh_empty.total_mass() ) ) );
289 r.push_back( std::to_string( to_kilogram( veh_fueled.total_mass() ) ) );
290 r.push_back( std::to_string( veh_fueled.max_velocity() / 100 ) );
291 r.push_back( std::to_string( veh_fueled.safe_velocity() / 100 ) );
292 r.push_back( std::to_string( veh_fueled.acceleration() / 100 ) );
293 r.push_back( std::to_string( veh_fueled.coeff_air_drag() ) );
294 r.push_back( std::to_string( veh_fueled.coeff_rolling_drag() ) );
295 r.push_back( std::to_string( veh_fueled.static_drag( false ) ) );
296 r.push_back( std::to_string( static_cast<int>( 50 *
297 veh_fueled.k_traction( veh_fueled.wheel_area() ) ) ) );
298 rows.push_back( r );
299 };
300 for( auto &e : vehicle_prototype::get_all() ) {
301 dump( e );
302 }
303
304 } else if( what == "VPART" ) {
305 header = {
306 "Name", "Location", "Weight", "Size"
307 };
308 auto dump = [&rows]( const vpart_info & obj ) {
309 std::vector<std::string> r;
310 r.push_back( obj.name() );
311 r.push_back( obj.location );
312 int w = std::ceil( to_gram( item( obj.item ).weight() ) / 1000.0 );
313 r.push_back( std::to_string( w ) );
314 r.push_back( std::to_string( obj.size / units::legacy_volume_factor ) );
315 rows.push_back( r );
316 };
317 for( const auto &e : vpart_info::all() ) {
318 dump( e.second );
319 }
320
321 } else {
322 std::cerr << "unknown argument: " << what << std::endl;
323 return false;
324 }
325
326 rows.erase( std::remove_if( rows.begin(), rows.end(), []( const std::vector<std::string> &e ) {
327 return e.empty();
328 } ), rows.end() );
329
330 if( scol >= 0 ) {
331 std::sort( rows.begin(), rows.end(), [&scol]( const std::vector<std::string> &lhs,
332 const std::vector<std::string> &rhs ) {
333 return localized_compare( lhs[ scol ], rhs[ scol ] );
334 } );
335 }
336
337 rows.erase( std::unique( rows.begin(), rows.end() ), rows.end() );
338
339 switch( mode ) {
340 case dump_mode::TSV:
341 rows.insert( rows.begin(), header );
342 for( const auto &r : rows ) {
343 // NOLINTNEXTLINE(cata-text-style): using tab to align the output
344 std::copy( r.begin(), r.end() - 1, std::ostream_iterator<std::string>( std::cout, "\t" ) );
345 std::cout << r.back() << "\n";
346 }
347 break;
348
349 case dump_mode::HTML:
350 std::cout << "<table>";
351
352 std::cout << "<thead>";
353 std::cout << "<tr>";
354 for( const auto &col : header ) {
355 std::cout << "<th>" << col << "</th>";
356 }
357 std::cout << "</tr>";
358 std::cout << "</thead>";
359
360 std::cout << "<tdata>";
361 for( const auto &r : rows ) {
362 std::cout << "<tr>";
363 for( const auto &col : r ) {
364 std::cout << "<td>" << col << "</td>";
365 }
366 std::cout << "</tr>";
367 }
368 std::cout << "</tdata>";
369
370 std::cout << "</table>";
371 break;
372 }
373
374 return true;
375}
body_part get_body_part_token(const std::string &id)
Returns the matching body_part token from the corresponding body_part string.
Definition: bodypart.cpp:180
body_part
Definition: bodypart.h:39
std::string to_string(const time_duration &d)
Returns a string showing a duration.
Definition: calendar.cpp:327
Definition: skill.h:33
static std::vector< Skill > skills
Definition: skill.h:49
const skill_id & ident() const
Definition: skill.h:65
bool load_packs(const std::string &msg, const std::vector< mod_id > &packs, loading_ui &ui)
Load content packs.
Definition: game.cpp:2981
units::mass weight(bool include_contents=true, bool integral=false) const
Definition: item.cpp:4838
void put_in(const item &payload)
Puts the given item into this one, no checks are performed.
Definition: item.cpp:989
item & ammo_set(const itype_id &ammo, int qty=-1)
Filter setting the ammo for this instance Any existing ammo is removed.
Definition: item.cpp:589
std::set< constrecipe * >::const_iterator begin() const
std::set< constrecipe * >::const_iterator end() const
void include(const recipe *r, int custom_difficulty=-1)
Include a recipe to the subset.
Definition: recipe.h:35
An NPC with standard stats.
Definition: npc.h:1394
static const std::map< vitamin_id, vitamin > & all()
Get all currently loaded vitamins.
Definition: vitamin.cpp:98
static const std::map< vpart_id, vpart_info > & all()
Definition: veh_type.cpp:694
static const std::string flag_VARSIZE("VARSIZE")
std::unique_ptr< Item_factory > item_controller
void transform(player &p, const tripoint &pos)
Transform the examined object into the object specified by its transforms_into property.
Definition: iexamine.cpp:1589
static constexpr volume legacy_volume_factor
Definition: units_volume.h:50
constexpr value_type to_gram(const quantity< value_type, mass_in_milligram_tag > &v)
Definition: units_mass.h:67
constexpr value_type to_kilogram(const quantity< value_type, mass_in_milligram_tag > &v)
Definition: units_mass.h:73
std::string enumerate_as_string(const _Container &values, enumeration_conjunction conj=enumeration_conjunction::and_)
Definition: output.h:679
recipe_dictionary recipe_dict
float total_damage() const
Definition: damage.cpp:75
std::vector< damage_unit >::iterator begin()
Definition: damage.cpp:120
bool empty() const
Definition: damage.cpp:88
Default (or randomized) charges except if counted by charges then only one charge.
Definition: item.h:196
Definition: itype.h:836
static std::vector< vproto_id > get_all()
Definition: veh_type.cpp:1157
string_id< MOD_INFORMATION > mod_id
Definition: type_id.h:91

References _, vitamin::all(), item::ammo_capacity(), item::ammo_default(), item::ammo_set(), damage_instance::begin(), item::covers(), damage_instance::empty(), enumerate_as_string(), DynamicDataLoader::finalize_loaded_data(), flag_VARSIZE(), g, get_body_part_token(), DynamicDataLoader::get_instance(), itype::gun, item::has_flag(), Skill::ident(), recipe_subset::include(), item_controller, itype_id, units::legacy_volume_factor, load_core_data(), load_packs(), anonymous_namespace{overmap_location.cpp}::locations, item::magazine_default(), item::magazine_integral(), none, num_bp, item::put_in(), recipe_dict, item::set_flag(), Skill::skills, units::to_gram(), to_string(), damage_instance::total_damage(), iexamine::transform(), calendar::turn, and item::type.

◆ events()

event_bus & game::events ( )

Definition at line 3091 of file game.cpp.

3092{
3093 return *event_bus_ptr;
3094}
pimpl< event_bus > event_bus_ptr
Definition: game.h:1001

References event_bus_ptr.

Referenced by cleanup_at_end(), and game().

◆ exam_vehicle()

void game::exam_vehicle ( vehicle veh,
const point cp = point_zero 
)

open vehicle interaction screen

Definition at line 5294 of file game.cpp.

5295{
5296 if( veh.magic ) {
5297 add_msg( m_info, _( "This is your %s" ), veh.name );
5298 return;
5299 }
5300 auto act = veh_interact::run( veh, c );
5301 if( act ) {
5302 u.moves = 0;
5304 }
5305}
static player_activity run(vehicle &veh, const point &p)
bool magic
Definition: vehicle.h:1866
constexpr double c
Definition: magic.cpp:1032
activity_id act
Definition: sounds.cpp:75

References _, act, add_msg(), Character::assign_activity(), c, m_info, vehicle::magic, Creature::moves, vehicle::name, veh_interact::run(), and u.

◆ examine() [1/2]

void game::examine ( )
private

Definition at line 5674 of file game.cpp.

5675{
5676 // if we are driving a vehicle, examine the
5677 // current tile without asking.
5678 const optional_vpart_position vp = m.veh_at( u.pos() );
5679 if( vp && vp->vehicle().player_in_control( u ) ) {
5680 examine( u.pos() );
5681 return;
5682 }
5683
5684 const cata::optional<tripoint> examp_ = choose_adjacent_highlight( _( "Examine where?" ),
5685 _( "There is nothing that can be examined nearby." ),
5686 ACTION_EXAMINE, false );
5687 if( !examp_ ) {
5688 return;
5689 }
5690 u.manual_examine = true;
5691 examine( *examp_ );
5692 u.manual_examine = false;
5693}
cata::optional< tripoint > choose_adjacent_highlight(const std::string &message, const std::string &failure_message, const action_id action, bool allow_vertical)
Request player input of adjacent tile with highlighting, possibly on different z-level.
Definition: action.cpp:1033
@ ACTION_EXAMINE
Examine or pick up items from adjacent square.
Definition: action.h:105
void examine()
Definition: game.cpp:5674
bool manual_examine
Definition: player.h:655

References _, ACTION_EXAMINE, choose_adjacent_highlight(), examine(), m, player::manual_examine, Character::pos(), u, and map::veh_at().

Referenced by examine(), and handle_action().

◆ examine() [2/2]

void game::examine ( const tripoint p)
private

Definition at line 5762 of file game.cpp.

5763{
5764 if( disable_robot( examp ) ) {
5765 return;
5766 }
5767
5768 Creature *c = critter_at( examp );
5769 if( c != nullptr ) {
5770 monster *mon = dynamic_cast<monster *>( c );
5771 if( mon != nullptr ) {
5772 add_msg( _( "There is a %s." ), mon->get_name() );
5773 if( mon->has_effect( effect_pet ) && !u.is_mounted() ) {
5774 if( monexamine::pet_menu( *mon ) ) {
5775 return;
5776 }
5777 } else if( mon->has_flag( MF_RIDEABLE_MECH ) && !mon->has_effect( effect_pet ) ) {
5778 if( monexamine::mech_hack( *mon ) ) {
5779 return;
5780 }
5781 } else if( mon->has_flag( MF_PAY_BOT ) ) {
5782 if( monexamine::pay_bot( *mon ) ) {
5783 return;
5784 }
5785 } else if( mon->attitude_to( u ) == Creature::A_FRIENDLY && !u.is_mounted() ) {
5786 if( monexamine::mfriend_menu( *mon ) ) {
5787 return;
5788 }
5789 }
5790 } else if( u.is_mounted() ) {
5791 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5792 }
5793 npc *np = dynamic_cast<npc *>( c );
5794 if( np != nullptr && !u.is_mounted() ) {
5795 if( npc_menu( *np ) ) {
5796 return;
5797 }
5798 } else if( np != nullptr && u.is_mounted() ) {
5799 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5800 }
5801 }
5802
5803 const optional_vpart_position vp = m.veh_at( examp );
5804 if( vp && u.is_mounted() ) {
5805 if( !u.mounted_creature->has_flag( MF_RIDEABLE_MECH ) ) {
5806 add_msg( m_warning, _( "You cannot interact with a vehicle while mounted." ) );
5807 } else {
5808 vp->vehicle().interact_with( examp, vp->part_index() );
5809 return;
5810 }
5811 } else if( vp && !u.is_mounted() ) {
5812 vp->vehicle().interact_with( examp, vp->part_index() );
5813 return;
5814 }
5815
5816 if( m.has_flag( "CONSOLE", examp ) && !u.is_mounted() ) {
5817 use_computer( examp );
5818 return;
5819 } else if( m.has_flag( "CONSOLE", examp ) && u.is_mounted() ) {
5820 add_msg( m_warning, _( "You cannot use a console while mounted." ) );
5821 }
5822 const furn_t &xfurn_t = m.furn( examp ).obj();
5823 const ter_t &xter_t = m.ter( examp ).obj();
5824
5825 const tripoint player_pos = u.pos();
5826
5827 if( m.has_furn( examp ) && !u.is_mounted() ) {
5828 xfurn_t.examine( u, examp );
5829 } else if( m.has_furn( examp ) && u.is_mounted() ) {
5830 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5831 } else {
5832 if( !u.is_mounted() ) {
5833 xter_t.examine( u, examp );
5834 } else if( u.is_mounted() && xter_t.examine == &iexamine::none ) {
5835 xter_t.examine( u, examp );
5836 } else {
5837 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5838 }
5839 }
5840
5841 // Did the player get moved? Bail out if so; our examp probably
5842 // isn't valid anymore.
5843 if( player_pos != u.pos() ) {
5844 return;
5845 }
5846
5847 bool none = true;
5848 if( xter_t.examine != &iexamine::none || xfurn_t.examine != &iexamine::none ) {
5849 none = false;
5850 }
5851
5852 if( !m.tr_at( examp ).is_null() && !u.is_mounted() ) {
5853 iexamine::trap( u, examp );
5854 } else if( !m.tr_at( examp ).is_null() && u.is_mounted() ) {
5855 add_msg( m_warning, _( "You cannot do that while mounted." ) );
5856 }
5857
5858 // In case of teleport trap or somesuch
5859 if( player_pos != u.pos() ) {
5860 return;
5861 }
5862
5863 // Feedback for fire lasting time, this can be judged while mounted
5864 const std::string fire_fuel = get_fire_fuel_string( examp );
5865 if( !fire_fuel.empty() ) {
5866 add_msg( fire_fuel );
5867 }
5868
5869 if( m.has_flag( "SEALED", examp ) ) {
5870 if( none ) {
5871 if( m.has_flag( "UNSTABLE", examp ) ) {
5872 add_msg( _( "The %s is too unstable to remove anything." ), m.name( examp ) );
5873 } else {
5874 add_msg( _( "The %s is firmly sealed." ), m.name( examp ) );
5875 }
5876 }
5877 } else {
5878 //examp has no traps, is a container and doesn't have a special examination function
5879 if( m.tr_at( examp ).is_null() && m.i_at( examp ).empty() &&
5880 m.has_flag( "CONTAINER", examp ) && none ) {
5881 add_msg( _( "It is empty." ) );
5882 } else if( ( m.has_flag( TFLAG_FIRE_CONTAINER, examp ) &&
5883 xfurn_t.examine == &iexamine::fireplace ) ||
5884 xfurn_t.examine == &iexamine::workbench ) {
5885 return;
5886 } else {
5888 if( !u.is_mounted() ) {
5889 pickup::pick_up( examp, 0 );
5890 }
5891 }
5892 }
5893}
shared_ptr_fast< monster > mounted_creature
Definition: character.h:1564
@ A_FRIENDLY
Definition: creature.h:171
void use_computer(const tripoint &p)
Checks to see if a player can use a computer (not illiterate, etc.) and uses if able.
Definition: game.cpp:4824
bool disable_robot(const tripoint &p)
If there is a robot (that can be disabled), query the player and try to disable it.
Definition: game.cpp:9198
bool npc_menu(npc &who)
Returns true if the menu handled stuff and player shouldn't do anything else.
Definition: game.cpp:5565
bool empty() const
Definition: item_stack.cpp:15
bool has_furn(const tripoint &p) const
Definition: map.cpp:1338
const trap & tr_at(const tripoint &p) const
Definition: map.cpp:5115
ter_id ter(const tripoint &p) const
Definition: map.cpp:1493
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
Definition: monster.cpp:1020
std::string get_name() const override
Definition: monster.cpp:487
static const efftype_id effect_pet("pet")
static std::string get_fire_fuel_string(const tripoint &examp)
Definition: game.cpp:5695
@ TFLAG_FIRE_CONTAINER
Definition: mapdata.h:293
void fireplace(player &p, const tripoint &examp)
Definition: iexamine.cpp:2841
void workbench(player &p, const tripoint &examp)
Definition: iexamine.cpp:6022
void none(player &p, const tripoint &examp)
Nothing player can interact with here.
Definition: iexamine.cpp:244
void trap(player &p, const tripoint &examp)
Definition: iexamine.cpp:3740
bool pet_menu(monster &z)
Definition: monexamine.cpp:64
bool mech_hack(monster &z)
Definition: monexamine.cpp:373
bool mfriend_menu(monster &z)
Definition: monexamine.cpp:445
bool pay_bot(monster &z)
Definition: monexamine.cpp:405
void pick_up(const tripoint &p, int min, from_where get_items_from=prompt)
Pick up items; 'g' or ',' or via examine()
Definition: pickup.cpp:571
iexamine_function examine
Definition: mapdata.h:398
Definition: mapdata.h:457
bool is_null() const
Whether this is the null-traps, aka no trap at all.
Definition: trap.cpp:245

References _, Creature::A_FRIENDLY, add_msg(), monster::attitude_to(), c, critter_at(), disable_robot(), effect_pet, item_stack::empty(), map_data_common_t::examine, iexamine::fireplace(), map::furn(), get_fire_fuel_string(), monster::get_name(), Creature::has_effect(), map::has_flag(), monster::has_flag(), map::has_furn(), map::i_at(), Character::is_mounted(), trap::is_null(), m, m_warning, monexamine::mech_hack(), MF_PAY_BOT, MF_RIDEABLE_MECH, monexamine::mfriend_menu(), Character::mounted_creature, map::name(), none, iexamine::none(), npc_menu(), int_id< T >::obj(), monexamine::pay_bot(), monexamine::pet_menu(), pickup::pick_up(), Character::pos(), sounds::process_sound_markers(), map::ter(), TFLAG_FIRE_CONTAINER, map::tr_at(), iexamine::trap(), u, use_computer(), map::veh_at(), and iexamine::workbench().

◆ extended_description()

void game::extended_description ( const tripoint p)

Long description of (visible) things at tile.

Definition at line 50 of file descriptions.cpp.

51{
53 const int top = 3;
54 int width = 0;
55 catacurses::window w_head;
56 catacurses::window w_main;
57 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
58 const int left = 0;
59 const int right = TERMX;
60 const int bottom = TERMY;
61 width = right - left;
62 const int height = bottom - top;
63 w_head = catacurses::newwin( top, TERMX, point_zero );
64 w_main = catacurses::newwin( height, width, point( left, top ) );
65 ui.position( point_zero, point( TERMX, TERMY ) );
66 } );
67 ui.mark_resize();
68
69 // Default to critter (if any), furniture (if any), then terrain.
71 if( seen_critter( *this, p ) != nullptr ) {
73 } else if( get_map().has_furn( p ) ) {
75 }
76
77 std::string action;
78 input_context ctxt( "EXTENDED_DESCRIPTION" );
79 ctxt.register_action( "CREATURE" );
80 ctxt.register_action( "FURNITURE" );
81 ctxt.register_action( "TERRAIN" );
82 ctxt.register_action( "CONFIRM" );
83 ctxt.register_action( "QUIT" );
84 ctxt.register_action( "HELP_KEYBINDINGS" );
85
86 ui.on_redraw( [&]( const ui_adaptor & ) {
87 werase( w_head );
89 _( "[%s] describe creatures, [%s] describe furniture, "
90 "[%s] describe terrain, [%s] close." ),
91 ctxt.get_desc( "CREATURE" ), ctxt.get_desc( "FURNITURE" ),
92 ctxt.get_desc( "TERRAIN" ), ctxt.get_desc( "QUIT" ) );
93
94 // Set up line drawings
95 for( int i = 0; i < TERMX; i++ ) {
96 mvwputch( w_head, point( i, top - 1 ), c_white, LINE_OXOX );
97 }
98
99 wnoutrefresh( w_head );
100
101 std::string desc;
102 // Allow looking at invisible tiles - player may want to examine hallucinations etc.
103 switch( cur_target ) {
105 const Creature *critter = seen_critter( *this, p );
106 if( critter != nullptr ) {
107 desc = critter->extended_description();
108 } else {
109 desc = _( "You do not see any creature here." );
110 }
111 }
112 break;
114 if( !u.sees( p ) || !m.has_furn( p ) ) {
115 desc = _( "You do not see any furniture here." );
116 } else {
117 const furn_id fid = m.furn( p );
118 desc = fid.obj().extended_description();
119 }
120 break;
122 if( !u.sees( p ) ) {
123 desc = _( "You can't see the terrain here." );
124 } else {
125 const ter_id tid = m.ter( p );
126 desc = tid.obj().extended_description();
127 }
128 break;
129 }
130
131 std::string signage = m.get_signage( p );
132 if( !signage.empty() ) {
133 // NOLINTNEXTLINE(cata-text-style): the question mark does not end a sentence
134 desc += u.has_trait( trait_ILLITERATE ) ? _( "\nSign: ???" ) : string_format( _( "\nSign: %s" ),
135 signage );
136 }
137
138 werase( w_main );
139 fold_and_print_from( w_main, point_zero, width, 0, c_light_gray, desc );
140 wnoutrefresh( w_main );
141 } );
142
143 do {
145 action = ctxt.handle_input();
146 if( action == "CREATURE" ) {
147 cur_target = description_target::creature;
148 } else if( action == "FURNITURE" ) {
150 } else if( action == "TERRAIN" ) {
151 cur_target = description_target::terrain;
152 }
153 } while( action != "CONFIRM" && action != "QUIT" );
154}
virtual std::string extended_description() const =0
friend map & get_map()
Definition: map.cpp:142
std::string get_signage(const tripoint &p) const
Definition: map.cpp:3979
static const trait_id trait_ILLITERATE("ILLITERATE")
static const Creature * seen_critter(const game &g, const tripoint &p)
description_target
int fold_and_print_from(const catacurses::window &w, const point &begin, int width, int begin_line, const nc_color &base_color, const std::string &text)
Like fold_and_print, but starts the output with the N-th line of the folded string.
Definition: output.cpp:311
std::string extended_description() const

References _, action, c_light_gray, c_white, creature, map_data_common_t::extended_description(), Creature::extended_description(), fold_and_print_from(), map::furn(), furniture, input_context::get_desc(), get_map, map::get_signage(), input_context::handle_input(), map::has_furn(), Character::has_trait(), left, LINE_OXOX, m, mvwprintz(), mvwputch(), catacurses::newwin(), int_id< T >::obj(), point_zero, ui_manager::redraw(), input_context::register_action(), right, seen_critter(), Character::sees(), string_format(), map::ter(), TERMX, TERMY, terrain, trait_ILLITERATE, u, catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by look_around().

◆ find_nearby_items()

std::vector< map_item_stack > game::find_nearby_items ( int  iRadius)
private

Definition at line 7210 of file game.cpp.

7211{
7212 std::map<std::string, map_item_stack> temp_items;
7213 std::vector<map_item_stack> ret;
7214 std::vector<std::string> item_order;
7215
7216 if( u.is_blind() ) {
7217 return ret;
7218 }
7219
7220 for( auto &points_p_it : closest_points_first( u.pos(), iRadius ) ) {
7221 if( points_p_it.y >= u.posy() - iRadius && points_p_it.y <= u.posy() + iRadius &&
7222 u.sees( points_p_it ) &&
7223 m.sees_some_items( points_p_it, u ) ) {
7224
7225 for( auto &elem : m.i_at( points_p_it ) ) {
7226 const std::string name = elem.tname();
7227 const tripoint relative_pos = points_p_it - u.pos();
7228
7229 if( std::find( item_order.begin(), item_order.end(), name ) == item_order.end() ) {
7230 item_order.push_back( name );
7231 temp_items[name] = map_item_stack( &elem, relative_pos );
7232 } else {
7233 temp_items[name].add_at_pos( &elem, relative_pos );
7234 }
7235 }
7236 }
7237 }
7238
7239 for( auto &elem : item_order ) {
7240 ret.push_back( temp_items[elem] );
7241 }
7242
7243 return ret;
7244}
bool is_blind() const
Returns true if the player isn't able to see.
Definition: character.cpp:6357
std::vector< coords::coord_point< Point, Origin, Scale > > closest_points_first(const coords::coord_point< Point, Origin, Scale > &loc, int min_dist, int max_dist)
Definition: coordinates.h:596

References closest_points_first(), detail::find(), map::i_at(), Character::is_blind(), m, om_direction::name(), Character::pos(), Character::posy(), cata::hash64_detail::ret, Character::sees(), map::sees_some_items(), and u.

Referenced by list_items_monsters().

◆ find_npc()

npc * game::find_npc ( character_id  id)

Find the npc with the given ID.

Returns NULL if the npc could not be found. Searches all loaded overmaps.

Definition at line 1955 of file game.cpp.

1956{
1957 return overmap_buffer.find_npc( id ).get();
1958}

References overmapbuffer::find_npc(), and overmap_buffer.

Referenced by critter_by_id().

◆ find_or_make_stairs()

cata::optional< tripoint > game::find_or_make_stairs ( map mp,
int  z_after,
bool &  rope_ladder,
bool  peeking 
)

Returns the other end of the stairs (if any).

May query, affect u etc.

Definition at line 10985 of file game.cpp.

10987{
10988 const int omtilesz = SEEX * 2;
10989 real_coords rc( m.getabs( point( u.posx(), u.posy() ) ) );
10990 tripoint omtile_align_start( m.getlocal( rc.begin_om_pos() ), z_after );
10991 tripoint omtile_align_end( omtile_align_start + point( -1 + omtilesz, -1 + omtilesz ) );
10992
10993 // Try to find the stairs.
10995 int best = INT_MAX;
10996 const int movez = z_after - get_levz();
10997 const bool going_down_1 = movez == -1;
10998 const bool going_up_1 = movez == 1;
10999 // If there are stairs on the same x and y as we currently are, use those
11000 if( going_down_1 && mp.has_flag( TFLAG_GOES_UP, u.pos() + tripoint_below ) ) {
11001 stairs.emplace( u.pos() + tripoint_below );
11002 }
11003 if( going_up_1 && mp.has_flag( TFLAG_GOES_DOWN, u.pos() + tripoint_above ) ) {
11004 stairs.emplace( u.pos() + tripoint_above );
11005 }
11006 // We did not find stairs directly above or below, so search the map for them
11007 if( !stairs.has_value() ) {
11008 for( const tripoint &dest : m.points_in_rectangle( omtile_align_start, omtile_align_end ) ) {
11009 if( rl_dist( u.pos(), dest ) <= best &&
11010 ( ( going_down_1 && mp.has_flag( TFLAG_GOES_UP, dest ) ) ||
11011 ( going_up_1 && ( mp.has_flag( TFLAG_GOES_DOWN, dest ) ||
11012 mp.ter( dest ) == t_manhole_cover ) ) ||
11013 ( ( movez == 2 || movez == -2 ) && mp.ter( dest ) == t_elevator ) ) ) {
11014 stairs.emplace( dest );
11015 best = rl_dist( u.pos(), dest );
11016 }
11017 }
11018 }
11019
11020 if( stairs.has_value() ) {
11021 if( Creature *blocking_creature = critter_at( stairs.value() ) ) {
11022 npc *guy = dynamic_cast<npc *>( blocking_creature );
11023 monster *mon = dynamic_cast<monster *>( blocking_creature );
11024 bool would_move = ( guy && !guy->is_enemy() ) || ( mon && mon->friendly == -1 );
11025 bool can_displace = find_empty_spot_nearby( *stairs ).has_value();
11026 std::string cr_name = blocking_creature->get_name();
11027 std::string msg;
11028 if( guy ) {
11029 //~ %s is the name of hostile NPC
11030 msg = string_format( _( "%s is in the way!" ), cr_name );
11031 } else {
11032 //~ %s is some monster
11033 msg = string_format( _( "There's a %s in the way!" ), cr_name );
11034 }
11035
11036 if( ( peeking && !would_move ) || !can_displace || ( !would_move && !query_yn(
11037 //~ %s is a warning about monster/hostile NPC in the way, e.g. "There's a zombie in the way!"
11038 _( "%s Attempt to push past? You may have to fight your way back up." ), msg ) ) ) {
11039 add_msg( msg );
11040 return cata::nullopt;
11041 }
11042 }
11043 return stairs;
11044 }
11045
11046 // No stairs found! Try to make some
11047 rope_ladder = false;
11048 stairs.emplace( u.pos() );
11049 stairs->z = z_after;
11050 // Check the destination area for lava.
11051 if( mp.ter( *stairs ) == t_lava ) {
11052 if( movez < 0 &&
11053 !query_yn(
11054 _( "There is a LOT of heat coming out of there, even the stairs have melted away. Jump down? You won't be able to get back up." ) ) ) {
11055 return cata::nullopt;
11056 } else if( movez > 0 &&
11057 !query_yn(
11058 _( "There is a LOT of heat coming out of there. Push through the half-molten rocks and ascend? You will not be able to get back down." ) ) ) {
11059 return cata::nullopt;
11060 }
11061
11062 return stairs;
11063 }
11064
11065 if( movez > 0 ) {
11066 if( !mp.has_flag( "GOES_DOWN", *stairs ) ) {
11067 if( !query_yn( _( "You may be unable to return back down these stairs. Continue up?" ) ) ) {
11068 return cata::nullopt;
11069 }
11070 }
11071 // Manhole covers need this to work
11072 // Maybe require manhole cover here and fail otherwise?
11073 return stairs;
11074 }
11075
11076 if( mp.impassable( *stairs ) ) {
11077 popup( _( "Halfway down, the way down becomes blocked off." ) );
11078 return cata::nullopt;
11079 }
11080
11081 if( u.has_trait( trait_id( "WEB_RAPPEL" ) ) ) {
11082 if( query_yn( _( "There is a sheer drop halfway down. Web-descend?" ) ) ) {
11083 rope_ladder = true;
11084 if( ( rng( 4, 8 ) ) < u.get_skill_level( skill_dodge ) ) {
11085 add_msg( _( "You attach a web and dive down headfirst, flipping upright and landing on your feet." ) );
11086 } else {
11087 add_msg( _( "You securely web up and work your way down, lowering yourself safely." ) );
11088 }
11089 } else {
11090 return cata::nullopt;
11091 }
11092 } else if( u.has_trait( trait_VINES2 ) || u.has_trait( trait_VINES3 ) ) {
11093 if( query_yn( _( "There is a sheer drop halfway down. Use your vines to descend?" ) ) ) {
11094 if( u.has_trait( trait_VINES2 ) ) {
11095 if( query_yn( _( "Detach a vine? It'll hurt, but you'll be able to climb back up…" ) ) ) {
11096 rope_ladder = true;
11097 add_msg( m_bad, _( "You descend on your vines, though leaving a part of you behind stings." ) );
11098 u.mod_pain( 5 );
11099 u.apply_damage( nullptr, bodypart_id( "torso" ), 5 );
11100 u.mod_stored_nutr( 10 );
11101 u.mod_thirst( 10 );
11102 } else {
11103 add_msg( _( "You gingerly descend using your vines." ) );
11104 }
11105 } else {
11106 add_msg( _( "You effortlessly lower yourself and leave a vine rooted for future use." ) );
11107 rope_ladder = true;
11108 u.mod_stored_nutr( 10 );
11109 u.mod_thirst( 10 );
11110 }
11111 } else {
11112 return cata::nullopt;
11113 }
11114 } else if( u.has_amount( itype_grapnel, 1 ) ) {
11115 if( query_yn( _( "There is a sheer drop halfway down. Climb your grappling hook down?" ) ) ) {
11116 rope_ladder = true;
11118 } else {
11119 return cata::nullopt;
11120 }
11121 } else if( u.has_amount( itype_rope_30, 1 ) ) {
11122 if( query_yn( _( "There is a sheer drop halfway down. Climb your rope down?" ) ) ) {
11123 rope_ladder = true;
11125 } else {
11126 return cata::nullopt;
11127 }
11128 } else if( !query_yn( _( "There is a sheer drop halfway down. Jump?" ) ) ) {
11129 return cata::nullopt;
11130 }
11131
11132 return stairs;
11133}
int_id< body_part_type > bodypart_id
Definition: bodypart.h:23
void apply_damage(Creature *source, bodypart_id hurt, int dam, bool bypass_med=false) override
Actually hurt the player, hurts a body_part directly, no armor reduction.
Definition: character.cpp:8421
std::list< item > use_amount(itype_id it, int quantity, const std::function< bool(const item &)> &filter=return_true< item >)
Definition: character.cpp:9640
virtual void mod_thirst(int nthirst)
Definition: character.cpp:4430
virtual void mod_stored_nutr(int nnutr)
Definition: character.cpp:4320
int get_skill_level(const skill_id &ident) const
Definition: character.cpp:3359
T & emplace(Args &&... args)
Definition: optional.h:143
constexpr bool has_value() const noexcept
Definition: optional.h:120
tripoint getlocal(const tripoint &p) const
Inverse of getabs.
Definition: map.cpp:8220
bool impassable(const tripoint &p) const
Definition: map.cpp:1790
tripoint_range< tripoint > points_in_rectangle(const tripoint &from, const tripoint &to) const
Definition: map.cpp:8549
bool is_enemy() const
Definition: npc.cpp:2040
void mod_pain(int npain) override
Modifies a pain value by player traits before passing it to Creature::mod_pain()
Definition: player.cpp:987
static const trait_id trait_VINES2("VINES2")
static const skill_id skill_dodge("dodge")
static cata::optional< tripoint > find_empty_spot_nearby(const tripoint &pos)
Definition: game.cpp:10521
static const itype_id itype_rope_30("rope_30")
static const itype_id itype_grapnel("grapnel")
static const trait_id trait_VINES3("VINES3")
ter_id t_manhole_cover
Definition: mapdata.cpp:720
ter_id t_lava
Definition: mapdata.cpp:695
ter_id t_elevator
Definition: mapdata.cpp:723
@ TFLAG_GOES_DOWN
Definition: mapdata.h:308
@ TFLAG_GOES_UP
Definition: mapdata.h:309
static constexpr nullopt_t nullopt
Definition: optional.h:22
static constexpr tripoint tripoint_below
Definition: point.h:295
static constexpr tripoint tripoint_above
Definition: point.h:294

References _, add_msg(), Character::apply_damage(), real_coords::begin_om_pos(), critter_at(), cata::optional< T >::emplace(), find_empty_spot_nearby(), monster::friendly, get_levz(), Character::get_skill_level(), map::getabs(), map::getlocal(), visitable< T >::has_amount(), map::has_flag(), Character::has_trait(), cata::optional< T >::has_value(), map::impassable(), npc::is_enemy(), itype_grapnel, itype_rope_30, m, m_bad, player::mod_pain(), Character::mod_stored_nutr(), Character::mod_thirst(), cata::nullopt, map::points_in_rectangle(), popup(), Character::pos(), Character::posx(), Character::posy(), query_yn(), rl_dist(), rng(), SEEX, skill_dodge, string_format(), t_elevator, t_lava, t_manhole_cover, map::ter(), TFLAG_GOES_DOWN, TFLAG_GOES_UP, trait_VINES2, trait_VINES3, tripoint_above, tripoint_below, u, Character::use_amount(), and cata::optional< T >::value().

Referenced by vertical_move().

◆ fling_creature()

void game::fling_creature ( Creature c,
const units::angle dir,
float  flvel,
bool  controlled = false,
bool  suppress_map_update = false 
)

Flings the input creature in the given direction.

Definition at line 10324 of file game.cpp.

10326{
10327 if( c == nullptr ) {
10328 debugmsg( "game::fling_creature invoked on null target" );
10329 return;
10330 }
10331
10332 if( c->is_dead_state() ) {
10333 // Flinging a corpse causes problems, don't enable without testing
10334 return;
10335 }
10336
10337 if( c->is_hallucination() ) {
10338 // Don't fling hallucinations
10339 return;
10340 }
10341
10342 bool thru = true;
10343 const bool is_u = ( c == &u );
10344 // Don't animate critters getting bashed if animations are off
10345 const bool animate = is_u || get_option<bool>( "ANIMATIONS" );
10346
10347 player *p = dynamic_cast<player *>( c );
10348
10349 tileray tdir( dir );
10350 int range = flvel / 10;
10351 tripoint pt = c->pos();
10352 tripoint prev_point = pt;
10353 bool force_next = false;
10354 tripoint next_forced;
10355 while( range > 0 ) {
10356 c->underwater = false;
10357 // TODO: Check whenever it is actually in the viewport
10358 // or maybe even just redraw the changed tiles
10359 bool seen = is_u || u.sees( *c ); // To avoid redrawing when not seen
10360 if( force_next ) {
10361 pt = next_forced;
10362 force_next = false;
10363 } else {
10364 tdir.advance();
10365 pt.x = c->posx() + tdir.dx();
10366 pt.y = c->posy() + tdir.dy();
10367 }
10368 float force = 0;
10369
10370 if( m.obstructed_by_vehicle_rotation( prev_point, pt ) ) {
10371 //We process the intervening tile on this iteration and then the current tile on the next
10372 next_forced = pt;
10373 force_next = true;
10374 if( one_in( 2 ) ) {
10375 pt.x = prev_point.x;
10376 } else {
10377 pt.y = prev_point.y;
10378 }
10379 }
10380
10381
10382 if( monster *const mon_ptr = critter_at<monster>( pt ) ) {
10383 monster &critter = *mon_ptr;
10384 // Approximate critter's "stopping power" with its max hp
10385 force = std::min<float>( 1.5f * critter.type->hp, flvel );
10386 const int damage = rng( force, force * 2.0f ) / 6;
10387 c->impact( damage, pt );
10388 // Multiply zed damage by 6 because no body parts
10389 const int zed_damage = std::max( 0,
10390 ( damage - critter.get_armor_bash( bodypart_id( "torso" ) ) ) * 6 );
10391 // TODO: Pass the "flinger" here - it's not the flung critter that deals damage
10392 critter.apply_damage( c, bodypart_id( "torso" ), zed_damage );
10393 critter.check_dead_state();
10394 if( !critter.is_dead() ) {
10395 thru = false;
10396 }
10397 } else if( m.impassable( pt ) ) {
10398 if( !m.veh_at( pt ).obstacle_at_part() ) {
10399 force = std::min<float>( m.bash_strength( pt ), flvel );
10400 } else {
10401 // No good way of limiting force here
10402 // Keep it 1 less than maximum to make the impact hurt
10403 // but to keep the target flying after it
10404 force = flvel - 1;
10405 }
10406 const int damage = rng( force, force * 2.0f ) / 9;
10407 c->impact( damage, pt );
10408 if( m.is_bashable( pt ) ) {
10409 // Only go through if we successfully make the tile passable
10410 m.bash( pt, flvel );
10411 thru = m.passable( pt );
10412 } else {
10413 thru = false;
10414 }
10415 }
10416
10417 // If the critter dies during flinging, moving it around causes debugmsgs
10418 if( c->is_dead_state() ) {
10419 return;
10420 }
10421
10422 flvel -= force;
10423 if( thru ) {
10424 if( p != nullptr ) {
10425 if( p->in_vehicle ) {
10426 m.unboard_vehicle( p->pos() );
10427 }
10428 // If we're flinging the player around, make sure the map stays centered on them.
10429 if( is_u && !suppress_map_update ) {
10430 update_map( pt.x, pt.y );
10431 } else {
10432 p->setpos( pt );
10433 }
10434 } else if( !critter_at( pt ) ) {
10435 // Dying monster doesn't always leave an empty tile (blob spawning etc.)
10436 // Just don't setpos if it happens - next iteration will do so
10437 // or the monster will stop a tile before the unpassable one
10438 c->setpos( pt );
10439 }
10440 } else {
10441 // Don't zero flvel - count this as slamming both the obstacle and the ground
10442 // although at lower velocity
10443 break;
10444 }
10445 //Vehicle wall tiles don't count for range
10446 if( !force_next ) {
10447 range--;
10448 }
10449 prev_point = pt;
10450 if( animate && ( seen || u.sees( *c ) ) ) {
10454 }
10455 }
10456
10457 // Fall down to the ground - always on the last reached tile
10458 if( !m.has_flag( "SWIMMABLE", c->pos() ) ) {
10459 const trap_id trap_under_creature = m.tr_at( c->pos() ).loadid;
10460 // Didn't smash into a wall or a floor so only take the fall damage
10461 if( thru && trap_under_creature == tr_ledge ) {
10462 m.creature_on_trap( *c, false );
10463 } else {
10464 // Fall on ground
10465 int force = rng( flvel, flvel * 2 ) / 9;
10466 if( controlled ) {
10467 force = std::max( force / 2 - 5, 0 );
10468 }
10469 if( force > 0 ) {
10470 int dmg = c->impact( force, c->pos() );
10471 // TODO: Make landing damage the floor
10472 m.bash( c->pos(), dmg / 4, false, false, false );
10473 }
10474 // Always apply traps to creature i.e. bear traps, tele traps etc.
10475 m.creature_on_trap( *c, false );
10476 }
10477 } else {
10478 c->underwater = true;
10479 if( is_u ) {
10480 if( controlled ) {
10481 add_msg( _( "You dive into water." ) );
10482 } else {
10483 add_msg( m_warning, _( "You fall into water." ) );
10484 }
10485 }
10486 }
10487}
void setpos(const tripoint &p) override
Definition: character.h:799
void check_dead_state()
This function checks the creatures is_dead_state and (if true) calls die.
Definition: creature.cpp:1839
point update_map(player &p)
Definition: game.cpp:11212
int bash_strength(const tripoint &p, bool allow_floor=false) const
Returns max_str of the furniture or terrain at p.
Definition: map.cpp:2444
bool obstructed_by_vehicle_rotation(const tripoint &from, const tripoint &to) const
Checks if a rotated vehicle is blocking diagonal movement, tripoints must be adjacent.
Definition: map.cpp:6464
bash_results bash(const tripoint &p, int str, bool silent=false, bool destroy=false, bool bash_floor=false, const vehicle *bashing_vehicle=nullptr)
Returns a pair where first is whether anything was smashed and second is if it was destroyed.
Definition: map.cpp:3506
void unboard_vehicle(const vpart_reference &, Character *passenger, bool dead_passenger=false)
Definition: map.cpp:1076
bool is_bashable(const tripoint &p, bool allow_floor=false) const
Returns true if there is a bashable vehicle part or the furn/terrain is bashable at p.
Definition: map.cpp:2409
void creature_on_trap(Creature &critter, bool may_avoid=true)
Apply trap effects to the creature, similar to creature_in_field.
Definition: map.cpp:8426
bool passable(const tripoint &p) const
Definition: map.cpp:1795
int get_armor_bash(bodypart_id bp) const override
Definition: monster.cpp:1859
bool is_dead() const
Definition: monster.cpp:2757
void apply_damage(Creature *source, bodypart_id bp, int dam, bool bypass_med=false) override
Definition: monster.cpp:1640
cata::optional< vpart_reference > obstacle_at_part() const
Definition: vehicle.cpp:2493
static const trap_str_id tr_ledge("tr_ledge")
void redraw_invalidated()
Definition: ui_manager.cpp:290
int hp
Definition: mtype.h:267
trap_id loadid
Definition: trap.h:88
int y
Definition: point.h:151
int x
Definition: point.h:150

References _, add_msg(), tileray::advance(), monster::apply_damage(), map::bash(), map::bash_strength(), c, Creature::check_dead_state(), map::creature_on_trap(), critter_at(), debugmsg, tileray::dx(), tileray::dy(), monster::get_armor_bash(), map::has_flag(), mtype::hp, map::impassable(), Character::in_vehicle, invalidate_main_ui_adaptor(), map::is_bashable(), monster::is_dead(), trap::loadid, m, m_warning, optional_vpart_position::obstacle_at_part(), map::obstructed_by_vehicle_rotation(), one_in(), map::passable(), Character::pos(), ui_manager::redraw_invalidated(), refresh_display(), rng(), Character::sees(), Character::setpos(), map::tr_at(), tr_ledge, monster::type, u, map::unboard_vehicle(), update_map(), map::veh_at(), tripoint::x, and tripoint::y.

Referenced by moving_vehicle_dismount().

◆ forced_door_closing()

bool game::forced_door_closing ( const tripoint p,
const ter_id door_type,
int  bash_dmg 
)

Definition at line 5307 of file game.cpp.

5308{
5309 // TODO: Z
5310 const int &x = p.x;
5311 const int &y = p.y;
5312 const std::string &door_name = door_type.obj().name();
5313 // sed when player/monsters are knocked back and when moving items out of the way
5314 point kb( x, y );
5315 const auto valid_location = [&]( const tripoint & p ) {
5316 return g->is_empty( p );
5317 };
5319 valid_location ) ) {
5320 kb.x = -pos->x + x + x;
5321 kb.y = -pos->y + y + y;
5322 }
5323 const tripoint kbp( kb, p.z );
5324 if( kbp == p ) {
5325 // can't pushback any creatures anywhere, that means the door can't close.
5326 return false;
5327 }
5328 const bool can_see = u.sees( tripoint( x, y, p.z ) );
5329 player *npc_or_player = critter_at<player>( tripoint( x, y, p.z ), false );
5330 if( npc_or_player != nullptr ) {
5331 if( bash_dmg <= 0 ) {
5332 return false;
5333 }
5334 if( npc_or_player->is_npc() && can_see ) {
5335 add_msg( _( "The %1$s hits the %2$s." ), door_name, npc_or_player->name );
5336 } else if( npc_or_player->is_player() ) {
5337 add_msg( m_bad, _( "The %s hits you." ), door_name );
5338 }
5339 if( npc_or_player->activity ) {
5340 npc_or_player->cancel_activity();
5341 }
5342 // TODO: make the npc angry?
5343 npc_or_player->hitall( bash_dmg, 0, nullptr );
5344 knockback( kbp, p, std::max( 1, bash_dmg / 10 ), -1, 1 );
5345 // TODO: perhaps damage/destroy the gate
5346 // if the npc was really big?
5347 }
5348 if( monster *const mon_ptr = critter_at<monster>( p ) ) {
5349 monster &critter = *mon_ptr;
5350 if( bash_dmg <= 0 ) {
5351 return false;
5352 }
5353 if( can_see ) {
5354 add_msg( _( "The %1$s hits the %2$s." ), door_name, critter.name() );
5355 }
5356 if( critter.type->size <= MS_SMALL ) {
5357 critter.die_in_explosion( nullptr );
5358 } else {
5359 critter.apply_damage( nullptr, bodypart_id( "torso" ), bash_dmg );
5360 critter.check_dead_state();
5361 }
5362 if( !critter.is_dead() && critter.type->size >= MS_HUGE ) {
5363 // big critters simply prevent the gate from closing
5364 // TODO: perhaps damage/destroy the gate
5365 // if the critter was really big?
5366 return false;
5367 }
5368 if( !critter.is_dead() ) {
5369 // Still alive? Move the critter away so the door can close
5370 knockback( kbp, p, std::max( 1, bash_dmg / 10 ), -1, 1 );
5371 if( critter_at( p ) ) {
5372 return false;
5373 }
5374 }
5375 }
5376 if( const optional_vpart_position vp = m.veh_at( p ) ) {
5377 if( bash_dmg <= 0 ) {
5378 return false;
5379 }
5380 vp->vehicle().damage( vp->part_index(), bash_dmg );
5381 if( m.veh_at( p ) ) {
5382 // Check again in case all parts at the door tile
5383 // have been destroyed, if there is still a vehicle
5384 // there, the door can not be closed
5385 return false;
5386 }
5387 }
5388 if( bash_dmg < 0 && !m.i_at( point( x, y ) ).empty() ) {
5389 return false;
5390 }
5391 if( bash_dmg == 0 ) {
5392 for( auto &elem : m.i_at( point( x, y ) ) ) {
5393 if( elem.made_of( LIQUID ) ) {
5394 // Liquids are OK, will be destroyed later
5395 continue;
5396 } else if( elem.volume() < 250_ml ) {
5397 // Dito for small items, will be moved away
5398 continue;
5399 }
5400 // Everything else prevents the door from closing
5401 return false;
5402 }
5403 }
5404
5405 m.ter_set( point( x, y ), door_type );
5406 if( m.has_flag( "NOITEM", point( x, y ) ) ) {
5407 map_stack items = m.i_at( point( x, y ) );
5408 for( map_stack::iterator it = items.begin(); it != items.end(); ) {
5409 if( it->made_of( LIQUID ) ) {
5410 it = items.erase( it );
5411 continue;
5412 }
5413 if( it->made_of( material_id( "glass" ) ) && one_in( 2 ) ) {
5414 if( can_see ) {
5415 add_msg( m_warning, _( "A %s shatters!" ), it->tname() );
5416 } else {
5417 add_msg( m_warning, _( "Something shatters!" ) );
5418 }
5419 it = items.erase( it );
5420 continue;
5421 }
5422 m.add_item_or_charges( kbp, *it );
5423 it = items.erase( it );
5424 }
5425 }
5426 return true;
5427}
int hitall(int dam, int vary, Creature *source)
Harms all body parts for dam, with armor reduction.
Definition: character.cpp:8689
void knockback(const tripoint &s, const tripoint &t, int force, int stun, int dam_mult)
Definition: game.cpp:4586
iterator erase(const_iterator it) override
Definition: map.cpp:148
bool ter_set(const tripoint &p, const ter_id &new_terrain)
Definition: map.cpp:1634
void die_in_explosion(Creature *source)
Definition: monster.cpp:1654
bool is_npc() const override
Definition: player.h:122
bool is_player() const override
Definition: player.h:105
@ MS_SMALL
Definition: creature.h:59
@ MS_HUGE
Definition: creature.h:62
@ LIQUID
Definition: enums.h:175
cata::optional< tripoint > random_point(const map &m, const std::function< bool(const tripoint &)> &predicate)
Same as other random_point with a range enclosing all valid points of the map.
std::string name() const
Definition: mapdata.cpp:511
m_size size
Definition: mtype.h:259

References _, Character::activity, map::add_item_or_charges(), add_msg(), monster::apply_damage(), item_stack::begin(), Character::cancel_activity(), Creature::check_dead_state(), critter_at(), monster::die_in_explosion(), item_stack::end(), map_stack::erase(), g, map::has_flag(), Character::hitall(), map::i_at(), monster::is_dead(), player::is_npc(), player::is_player(), knockback(), LIQUID, m, m_bad, m_warning, MS_HUGE, MS_SMALL, Character::name, map_data_common_t::name(), monster::name(), int_id< T >::obj(), one_in(), map::points_in_radius(), random_point(), Character::sees(), mtype::size, map::ter_set(), monster::type, u, map::veh_at(), point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

◆ gametype()

special_game_id game::gametype ( ) const

Definition at line 629 of file game.cpp.

630{
631 return gamemode ? gamemode->id() : SGAME_NULL;
632}
@ SGAME_NULL
Definition: enums.h:93

References gamemode, and SGAME_NULL.

◆ get_creature_if()

Creature * game::get_creature_if ( const std::function< bool(const Creature &)> &  pred)

Returns a creature matching a predicate.

Only living (not dead) creatures are checked. Returns nullptr if no creature matches the predicate. There is no guarantee which creature is returned when several creatures match.

Definition at line 12559 of file game.cpp.

12560{
12561 for( Creature &critter : all_creatures() ) {
12562 if( pred( critter ) ) {
12563 return &critter;
12564 }
12565 }
12566 return nullptr;
12567}

References all_creatures().

◆ get_creatures_if()

std::vector< Creature * > game::get_creatures_if ( const std::function< bool(const Creature &)> &  pred)

Returns all creatures matching a predicate.

Only living ( not dead ) creatures are checked ( and returned ). Returned pointers are never null.

Definition at line 12469 of file game.cpp.

12471{
12472 std::vector<Creature *> result;
12473 for( Creature &critter : all_creatures() ) {
12474 if( pred( critter ) ) {
12475 result.push_back( &critter );
12476 }
12477 }
12478 return result;
12479}

References all_creatures().

◆ get_cur_om()

overmap & game::get_cur_om ( ) const

The overmap which contains the center submap of the reality bubble.

Definition at line 12449 of file game.cpp.

12450{
12451 // The player is located in the middle submap of the map.
12453 const tripoint pos_om = sm_to_om_copy( sm );
12454 // TODO: fix point types
12455 return overmap_buffer.get( point_abs_om( pos_om.xy() ) );
12456}
tripoint get_abs_sub() const
return abs_sub
Definition: map.cpp:8230
overmap & get(const point_abs_om &)
Uses overmap coordinates, that means x and y are directly compared with the position of the overmap.
point sm_to_om_copy(const point &p)
coords::coord_point< point, coords::origin::abs, coords::om > point_abs_om
Definition: coordinates.h:483
static constexpr int HALF_MAPSIZE
constexpr scale sm
Definition: coordinates.h:31

References overmapbuffer::get(), map::get_abs_sub(), HALF_MAPSIZE, m, overmap_buffer, coords::sm, sm_to_om_copy(), and tripoint::xy().

Referenced by start_game().

◆ get_dangerous_tile()

std::vector< std::string > game::get_dangerous_tile ( const tripoint dest_loc) const

Definition at line 9281 of file game.cpp.

9282{
9283 std::vector<std::string> harmful_stuff;
9284 const auto fields_here = m.field_at( u.pos() );
9285 for( const auto &e : m.field_at( dest_loc ) ) {
9286 // warn before moving into a dangerous field except when already standing within a similar field
9287 if( u.is_dangerous_field( e.second ) && fields_here.find_field( e.first ) == nullptr ) {
9288 harmful_stuff.push_back( e.second.name() );
9289 }
9290 }
9291
9292 if( !u.is_blind() ) {
9293 const trap &tr = m.tr_at( dest_loc );
9294 const bool boardable = static_cast<bool>( m.veh_at( dest_loc ).part_with_feature( "BOARDABLE",
9295 true ) );
9296 // HACK: Hack for now, later ledge should stop being a trap
9297 // Note: in non-z-level mode, ledges obey different rules and so should be handled as regular traps
9298 if( tr.loadid == tr_ledge && m.has_zlevels() ) {
9299 if( !boardable ) {
9300 harmful_stuff.emplace_back( tr.name() );
9301 }
9302 } else if( tr.can_see( dest_loc, u ) && !tr.is_benign() && !boardable ) {
9303 harmful_stuff.emplace_back( tr.name() );
9304 }
9305
9306 static const std::set< body_part > sharp_bps = {
9309 };
9310
9311 const auto sharp_bp_check = [this]( body_part bp ) {
9312 return u.immune_to( bp, { DT_CUT, 10 } );
9313 };
9314
9315 if( m.has_flag( "ROUGH", dest_loc ) && !m.has_flag( "ROUGH", u.pos() ) && !boardable &&
9316 ( u.get_armor_bash( bodypart_id( "foot_l" ) ) < 5 ||
9317 u.get_armor_bash( bodypart_id( "foot_r" ) ) < 5 ) ) {
9318 harmful_stuff.emplace_back( m.name( dest_loc ) );
9319 } else if( m.has_flag( "SHARP", dest_loc ) && !m.has_flag( "SHARP", u.pos() ) && !( u.in_vehicle ||
9320 m.veh_at( dest_loc ) ) &&
9321 u.dex_cur < 78 && !std::all_of( sharp_bps.begin(), sharp_bps.end(), sharp_bp_check ) ) {
9322 harmful_stuff.emplace_back( m.name( dest_loc ) );
9323 }
9324
9325 }
9326
9327 return harmful_stuff;
9328}
@ bp_foot_l
Definition: bodypart.h:50
@ bp_leg_r
Definition: bodypart.h:49
@ bp_eyes
Definition: bodypart.h:42
@ bp_hand_l
Definition: bodypart.h:46
@ bp_arm_l
Definition: bodypart.h:44
@ bp_leg_l
Definition: bodypart.h:48
@ bp_hand_r
Definition: bodypart.h:47
@ bp_head
Definition: bodypart.h:41
@ bp_torso
Definition: bodypart.h:40
@ bp_mouth
Definition: bodypart.h:43
@ bp_foot_r
Definition: bodypart.h:51
@ bp_arm_r
Definition: bodypart.h:45
int dex_cur
Definition: character.h:247
int get_armor_bash(bodypart_id bp) const override
Returns overall bashing resistance for the body_part.
Definition: character.cpp:6985
bool is_dangerous_field(const field_entry &entry) const
Returns true if the given field entry is dangerous to us.
Definition: creature.cpp:196
const field & field_at(const tripoint &p) const
Get the fields that are here.
Definition: map.cpp:5277
bool has_zlevels() const
Definition: map.h:1677
cata::optional< vpart_reference > part_with_feature(const std::string &f, bool unbroken) const
Definition: vehicle.cpp:2481
bool immune_to(body_part bp, damage_unit dam) const
Check if a given body part is immune to a given damage type.
Definition: player.cpp:970
@ DT_CUT
Definition: damage.h:25
Definition: trap.h:86
std::string name() const
Definition: trap.cpp:177
bool can_see(const tripoint &pos, const Character &p) const
Can player/npc p see this kind of trap, either by their memory (they known there is the trap) or by t...
Definition: trap.cpp:223
bool is_benign() const
If true, this is not really a trap and there won't be any safety queries before stepping onto it (e....
Definition: trap.h:159

References bp_arm_l, bp_arm_r, bp_eyes, bp_foot_l, bp_foot_r, bp_hand_l, bp_hand_r, bp_head, bp_leg_l, bp_leg_r, bp_mouth, bp_torso, trap::can_see(), Character::dex_cur, DT_CUT, map::field_at(), Character::get_armor_bash(), map::has_flag(), map::has_zlevels(), player::immune_to(), Character::in_vehicle, trap::is_benign(), Character::is_blind(), Creature::is_dangerous_field(), trap::loadid, m, trap::name(), map::name(), optional_vpart_position::part_with_feature(), Character::pos(), map::tr_at(), tr_ledge, u, and map::veh_at().

Referenced by is_dangerous_tile(), prompt_dangerous_tile(), and walk_move().

◆ get_fishable_locations()

std::unordered_set< tripoint > game::get_fishable_locations ( int  distance,
const tripoint fish_pos 
)

Get the contiguous fishable locations starting at fish_pos, out to the specificed distance.

Parameters
distanceDistance around the fish_pos to examine for contiguous fishable locations.
fish_posThe location being fished.
Returns
A set of locations representing the valid contiguous fishable locations.

Definition at line 3973 of file game.cpp.

3974{
3975 // We're going to get the contiguous fishable terrain starting at
3976 // the provided fishing location (e.g. where a line was cast or a fish
3977 // trap was set), and then check whether or not fishable monsters are
3978 // actually in those locations. This will help us ensure that we're
3979 // getting our fish from the location that we're ACTUALLY fishing,
3980 // rather than just somewhere in the vicinity.
3981
3982 std::unordered_set<tripoint> visited;
3983
3984 const tripoint fishing_boundary_min( fish_pos + point( -distance, -distance ) );
3985 const tripoint fishing_boundary_max( fish_pos + point( distance, distance ) );
3986
3987 const inclusive_cuboid<tripoint> fishing_boundaries(
3988 fishing_boundary_min, fishing_boundary_max );
3989
3990 const auto get_fishable_terrain = [&]( tripoint starting_point,
3991 std::unordered_set<tripoint> &fishable_terrain ) {
3992 std::queue<tripoint> to_check;
3993 to_check.push( starting_point );
3994 while( !to_check.empty() ) {
3995 const tripoint current_point = to_check.front();
3996 to_check.pop();
3997
3998 // We've been here before, so bail.
3999 if( visited.find( current_point ) != visited.end() ) {
4000 continue;
4001 }
4002
4003 // This point is out of bounds, so bail.
4004 if( !fishing_boundaries.contains( current_point ) ) {
4005 continue;
4006 }
4007
4008 // Mark this point as visited.
4009 visited.emplace( current_point );
4010
4011 if( m.has_flag( "FISHABLE", current_point ) ) {
4012 fishable_terrain.emplace( current_point );
4013 to_check.push( current_point + point_south );
4014 to_check.push( current_point + point_north );
4015 to_check.push( current_point + point_east );
4016 to_check.push( current_point + point_west );
4017 }
4018 }
4019 return;
4020 };
4021
4022 // Starting at the provided location, get our fishable terrain
4023 // and populate a set with those locations which we'll then use
4024 // to determine if any fishable monsters are in those locations.
4025 std::unordered_set<tripoint> fishable_points;
4026 get_fishable_terrain( fish_pos, fishable_points );
4027
4028 return fishable_points;
4029}
static constexpr point point_west
Definition: point.h:282
static constexpr point point_south
Definition: point.h:280
static constexpr point point_north
Definition: point.h:276
static constexpr point point_east
Definition: point.h:278

References inclusive_cuboid< Tripoint, >::contains(), map::has_flag(), m, point_east, point_north, point_south, and point_west.

◆ get_fishable_monsters()

std::vector< monster * > game::get_fishable_monsters ( std::unordered_set< tripoint > &  fishable_locations)

Get the fishable monsters within the provided fishable locations.

Parameters
fishable_locationsA set of locations which are valid fishable terrain. Any fishable monsters are filtered by this collection to determine those which can actually be caught.
Returns
Fishable monsters within the specified fishable terrain.

Definition at line 4031 of file game.cpp.

4033{
4034 std::vector<monster *> unique_fish;
4035 for( monster &critter : all_monsters() ) {
4036 // If it is fishable...
4037 if( critter.has_flag( MF_FISHABLE ) ) {
4038 const tripoint critter_pos = critter.pos();
4039 // ...and it is in a fishable location.
4040 if( fishable_locations.find( critter_pos ) != fishable_locations.end() ) {
4041 unique_fish.push_back( &critter );
4042 }
4043 }
4044 }
4045
4046 return unique_fish;
4047}
@ MF_FISHABLE
Definition: mtype.h:142

References all_monsters(), and MF_FISHABLE.

◆ get_follower_list()

std::set< character_id > game::get_follower_list ( )

Get set of followers.

Definition at line 2052 of file game.cpp.

2053{
2054 return follower_ids;
2055}

References follower_ids.

◆ get_kill_tracker()

const kill_tracker & game::get_kill_tracker ( ) const

Definition at line 968 of file game.cpp.

969{
970 return *kill_tracker_ptr;
971}

References kill_tracker_ptr.

Referenced by cleanup_at_end(), death_screen(), handle_action(), and win().

◆ get_levx()

int game::get_levx ( ) const

The top left corner of the reality bubble (in submaps coordinates).

This is the same as map::abs_sub of the m map.

Definition at line 12434 of file game.cpp.

12435{
12436 return m.get_abs_sub().x;
12437}

References map::get_abs_sub(), m, and tripoint::x.

Referenced by create_starting_npcs(), load_npcs(), look_around(), save_cyborg(), spawn_hallucination(), vertical_move(), and vertical_shift().

◆ get_levy()

int game::get_levy ( ) const

Definition at line 12439 of file game.cpp.

12440{
12441 return m.get_abs_sub().y;
12442}

References map::get_abs_sub(), m, and tripoint::y.

Referenced by create_starting_npcs(), load_npcs(), look_around(), save_cyborg(), spawn_hallucination(), vertical_move(), and vertical_shift().

◆ get_levz()

◆ get_moves_since_last_save()

int game::get_moves_since_last_save ( ) const

Definition at line 7380 of file game.cpp.

7381{
7382 return moves_since_last_save;
7383}

References moves_since_last_save.

◆ get_npcs_if()

std::vector< npc * > game::get_npcs_if ( const std::function< bool(const npc &)> &  pred)

Definition at line 12481 of file game.cpp.

12482{
12483 std::vector<npc *> result;
12484 for( npc &guy : all_npcs() ) {
12485 if( pred( guy ) ) {
12486 result.push_back( &guy );
12487 }
12488 }
12489 return result;
12490}

References all_npcs().

Referenced by allies(), chat(), and validate_npc_followers().

◆ get_player_base_save_path()

std::string game::get_player_base_save_path ( ) const

Base path for saving player data.

Just add a suffix (unique for the thing you want to save) and use the resulting path. Example: save_ui_data(get_player_base_save_path()+".ui")

Definition at line 12569 of file game.cpp.

12570{
12571 return get_world_base_save_path() + "/" + base64_encode( u.name );
12572}
std::string base64_encode(const std::string &str)
std::string get_world_base_save_path() const
Base path for saving world data.
Definition: game.cpp:12574

References base64_encode(), get_world_base_save_path(), Character::name, and u.

Referenced by save_player_data().

◆ get_player_input()

input_context game::get_player_input ( std::string &  action)
private

Definition at line 237 of file handle_action.cpp.

238{
239 input_context ctxt;
240 if( uquit == QUIT_WATCH ) {
241 ctxt = input_context( "DEFAULTMODE" );
242 ctxt.set_iso( true );
243 // The list of allowed actions in death-cam mode in game::handle_action
244 // *INDENT-OFF*
245 for( const action_id id : {
258 } ) {
259 ctxt.register_action( action_ident( id ) );
260 }
261 // *INDENT-ON*
262 ctxt.register_action( "QUIT", to_translation( "Accept your fate" ) );
263 } else {
265 }
266
268
269 user_turn current_turn;
270
271
272 // Checking early if we will need to handle animations
273 // If we do not need to handle animations that will not change as long as the user has not selected an action
274 // and we can handle it like we are not animating.
275 weather_printable wPrint;
276 bool animate_weather = false;
277 bool animate_sct = false;
278 bool do_animations = [&]() {
279 if( get_option<bool>( "ANIMATIONS" ) ) {
280 const bool weather_has_anim = init_weather_anim( get_weather().weather_id, wPrint );
281
282 animate_weather = weather_has_anim && get_option<bool>( "ANIMATION_RAIN" );
283 animate_sct = !SCT.vSCT.empty() && uquit != QUIT_WATCH && get_option<bool>( "ANIMATION_SCT" );
284
285#if defined(TILES)
286 // Always animate, minimap and terrain may have animations to run
287 return true;
288#else
289 // Otherwise we need to see if we actually should animate.
290 // Minimap and Terrain never animate in !TILES
291 return animate_weather || animate_sct || uquit == QUIT_WATCH;
292#endif
293 }
294 return false;
295 }
296 ();
297
298 if( do_animations ) {
299 ctxt.set_timeout( 125 );
300
302 make_shared_fast<game::draw_callback_t>( [&]() {
303 if( animate_weather ) {
304 draw_weather( wPrint );
305 }
306 if( animate_sct ) {
307 draw_sct();
308 }
309 } );
310 add_draw_callback( animation_cb );
311 invalidate_main_ui_adaptor(); // We want to redraw at least once.
312
313 do {
314 if( animate_weather ) {
316 generate_weather_anim_frame( get_weather().weather_id, wPrint );
317 }
318 // don't bother calculating SCT if we won't show it
319 if( animate_sct ) {
321
323
324 //Check for creatures on all drawing positions and offset if necessary
325 for( auto iter = SCT.vSCT.rbegin(); iter != SCT.vSCT.rend(); ++iter ) {
326 const direction oCurDir = iter->getDirecton();
327 const int width = utf8_width( iter->getText() );
328 for( int i = 0; i < width; ++i ) {
329 tripoint tmp( iter->getPosX() + i, iter->getPosY(), get_levz() );
330 const Creature *critter = critter_at( tmp, true );
331
332 if( critter != nullptr && u.sees( *critter ) ) {
333 i = -1;
334 int iPos = iter->getStep() + iter->getStepOffset();
335 for( auto iter2 = iter; iter2 != SCT.vSCT.rend(); ++iter2 ) {
336 if( iter2->getDirecton() == oCurDir &&
337 iter2->getStep() + iter2->getStepOffset() <= iPos ) {
338 if( iter2->getType() == "hp" ) {
339 iter2->advanceStepOffset();
340 }
341
342 iter2->advanceStepOffset();
343 iPos = iter2->getStep() + iter2->getStepOffset();
344 }
345 }
346 }
347 }
348 }
349
350 // Stop animation when done
351 animate_sct = !SCT.vSCT.empty();
352 }
353 // We don't cache these checks as their result may change after 1st redraw
355 // TODO: we redraw *everything* just to animate a couple blinking dots
356 // on the minimap or a few tiles.
357 // This is far from ideal, and can probably be done much cheaper
358 // (update only part of the screen? draw static parts into a texture?)
360 }
361
362 std::unique_ptr<static_popup> deathcam_msg_popup;
363 if( uquit == QUIT_WATCH ) {
364 deathcam_msg_popup = std::make_unique<static_popup>();
365 deathcam_msg_popup
366 ->wait_message( c_red, _( "Press %s to accept your fate…" ), ctxt.get_desc( "QUIT" ) )
367 .on_top( true );
368 }
369
371 } while( handle_mouseview( ctxt, action ) && uquit != QUIT_WATCH
372 && ( action != "TIMEOUT" || !current_turn.has_timeout_elapsed() ) );
373 ctxt.reset_timeout();
374 } else {
377 SCT.vSCT.clear();
378
379 ctxt.set_timeout( 125 );
380 while( handle_mouseview( ctxt, action ) ) {
381 if( action == "TIMEOUT" && current_turn.has_timeout_elapsed() ) {
382 break;
383 }
384 }
385 ctxt.reset_timeout();
386 }
387
388 return ctxt;
389}
std::string action_ident(action_id act)
Lookup a unique string identifier for a given action ID.
Definition: action.cpp:67
action_id
Enumerates all discrete actions that can be performed by player.
Definition: action.h:22
@ ACTION_CENTER
Center the viewport on character.
Definition: action.h:77
@ ACTION_SHIFT_SW
Move viewport south-west.
Definition: action.h:89
@ ACTION_SHIFT_NW
Move viewport north-west.
Definition: action.h:93
@ ACTION_KEYBINDINGS
Display keybindings list.
Definition: action.h:257
@ ACTION_SHIFT_E
Move viewport east.
Definition: action.h:83
@ ACTION_TOGGLE_MAP_MEMORY
Toggle memorized tiles being shown.
Definition: action.h:75
@ ACTION_SHIFT_S
Move viewport south.
Definition: action.h:87
@ ACTION_SHIFT_SE
Move viewport south-east.
Definition: action.h:85
@ ACTION_LOOK
Toggle look mode.
Definition: action.h:119
@ ACTION_SHIFT_NE
Move viewport north-east.
Definition: action.h:81
@ ACTION_SHIFT_W
Move viewport west.
Definition: action.h:91
@ ACTION_SHIFT_N
Move viewport north.
Definition: action.h:79
bool terrain_requires_animation()
Definition: animation.cpp:1136
bool minimap_requires_animation()
Definition: animation.cpp:1127
void draw_sct()
Definition: animation.cpp:797
void draw_weather(const weather_printable &wPrint)
Definition: animation.cpp:756
void add_draw_callback(shared_ptr_fast< draw_callback_t > cb)
Definition: game.cpp:3386
bool handle_mouseview(input_context &ctxt, std::string &action)
Definition: game.cpp:2325
void set_timeout(int val)
Sets input polling timeout as appropriate for the current interface system.
Definition: input.cpp:1458
std::string get_desc(const std::string &action_descriptor, unsigned int max_limit=0, const input_event_filter &evt_filter=allow_all_keys) const
Get a description text for the key/other input method associated with the given action.
Definition: input.cpp:756
void register_action(const std::string &action_descriptor)
Register an action with this input context.
Definition: input.cpp:676
void set_iso(bool mode=true)
Definition: input.cpp:1429
void reset_timeout()
Definition: input.cpp:1463
std::vector< cSCT > vSCT
Definition: output.h:947
void advanceAllSteps()
Definition: output.cpp:1924
bool has_timeout_elapsed()
input_context get_default_mode_input_context()
Definition: game.cpp:2425
static bool init_weather_anim(const weather_type_id &wtype, weather_printable &wPrint)
static void generate_weather_anim_frame(const weather_type_id &wtype, weather_printable &wPrint)
direction
Definition: line.h:39
scrollingcombattext SCT
Definition: output.cpp:65
Weather drawing tracking.
Definition: weather.h:59
translation to_translation(const std::string &raw)
Shorthands for translation::to_translation.

References _, action, ACTION_CENTER, action_ident(), ACTION_KEYBINDINGS, ACTION_LOOK, ACTION_SHIFT_E, ACTION_SHIFT_N, ACTION_SHIFT_NE, ACTION_SHIFT_NW, ACTION_SHIFT_S, ACTION_SHIFT_SE, ACTION_SHIFT_SW, ACTION_SHIFT_W, ACTION_TOGGLE_MAP_MEMORY, add_draw_callback(), scrollingcombattext::advanceAllSteps(), c_red, critter_at(), draw_sct(), draw_weather(), generate_weather_anim_frame(), get_default_mode_input_context(), input_context::get_desc(), get_levz(), get_weather, handle_mouseview(), user_turn::has_timeout_elapsed(), init_weather_anim(), invalidate_main_ui_adaptor(), m, minimap_requires_animation(), Character::posz(), QUIT_WATCH, ui_manager::redraw_invalidated(), input_context::register_action(), input_context::reset_timeout(), SCT, Character::sees(), input_context::set_iso(), input_context::set_timeout(), terrain_requires_animation(), to_translation(), u, map::update_visibility_cache(), uquit, utf8_width(), and scrollingcombattext::vSCT.

Referenced by handle_action().

◆ get_seed()

unsigned int game::get_seed ( ) const

Definition at line 1864 of file game.cpp.

1865{
1866 return seed;
1867}

References seed.

◆ get_user_action_counter()

int game::get_user_action_counter ( ) const

Definition at line 7385 of file game.cpp.

7386{
7387 return user_action_counter;
7388}

References user_action_counter.

◆ get_veh_dir_indicator_location()

cata::optional< tripoint > game::get_veh_dir_indicator_location ( bool  next) const

Returns the location where the indicator should go relative to the reality bubble, or nothing to indicate no indicator should be drawn.

Based on the vehicle the player is driving, if any.

Parameters
nextIf true, bases it on the vehicle the vehicle will turn to next turn, instead of the one it is currently facing.

Definition at line 3641 of file game.cpp.

3642{
3643 if( !get_option<bool>( "VEHICLE_DIR_INDICATOR" ) ) {
3644 return cata::nullopt;
3645 }
3646 const optional_vpart_position vp = m.veh_at( u.pos() );
3647 if( !vp ) {
3648 return cata::nullopt;
3649 }
3650 vehicle *const veh = &vp->vehicle();
3651 rl_vec2d face = next ? veh->dir_vec() : veh->face_vec();
3652 float r = 10.0;
3653 return tripoint( static_cast<int>( r * face.x ), static_cast<int>( r * face.y ), u.pos().z );
3654}
rl_vec2d dir_vec() const

References vehicle::dir_vec(), vehicle::face_vec(), m, cata::nullopt, Character::pos(), u, map::veh_at(), rl_vec2d::x, rl_vec2d::y, and tripoint::z.

Referenced by draw_veh_dir_indicator().

◆ get_world_base_save_path()

std::string game::get_world_base_save_path ( ) const

Base path for saving world data.

This yields a path to a folder.

Definition at line 12574 of file game.cpp.

12575{
12576 if( world_generator->active_world == nullptr ) {
12577 return PATH_INFO::savedir();
12578 }
12579 return world_generator->active_world->folder_path();
12580}
std::string savedir()
Definition: path_info.cpp:250

References PATH_INFO::savedir(), and world_generator.

Referenced by get_player_base_save_path(), load(), load_master(), move_save_to_graveyard(), save(), save_artifacts(), and save_factions_missions_npcs().

◆ get_zoom()

int game::get_zoom ( ) const

Definition at line 7371 of file game.cpp.

7372{
7373#if defined(TILES)
7374 return tileset_zoom;
7375#else
7376 return DEFAULT_TILESET_ZOOM;
7377#endif
7378}

References DEFAULT_TILESET_ZOOM, and tileset_zoom.

Referenced by look_around().

◆ grabbed_furn_move()

bool game::grabbed_furn_move ( const tripoint dp)
private
Strength determines ability to drag furniture

Definition at line 10084 of file game.cpp.

10085{
10086 // Furniture: pull, push, or standing still and nudging object around.
10087 // Can push furniture out of reach.
10088 tripoint fpos = u.pos() + u.grab_point;
10089 // supposed position of grabbed furniture
10090 if( !m.has_furn( fpos ) ) {
10091 // Where did it go? We're grabbing thin air so reset.
10092 add_msg( m_info, _( "No furniture at grabbed point." ) );
10093 u.grab( OBJECT_NONE );
10094 return false;
10095 }
10096
10097 const bool pushing_furniture = dp == u.grab_point;
10098 const bool pulling_furniture = dp == -u.grab_point;
10099 const bool shifting_furniture = !pushing_furniture && !pulling_furniture;
10100
10101 tripoint fdest = fpos + dp; // intended destination of furniture.
10102 // Check floor: floorless tiles don't need to be flat and have no traps
10103 const bool has_floor = m.has_floor( fdest );
10104 // Unfortunately, game::is_empty fails for tiles we're standing on,
10105 // which will forbid pulling, so:
10106 const bool canmove = (
10107 m.passable( fdest ) &&
10108 critter_at<npc>( fdest ) == nullptr &&
10109 critter_at<monster>( fdest ) == nullptr &&
10110 ( !pulling_furniture || is_empty( u.pos() + dp ) ) &&
10111 ( !has_floor || m.has_flag( "FLAT", fdest ) ) &&
10112 !m.has_furn( fdest ) &&
10113 !m.veh_at( fdest ) &&
10114 ( !has_floor || m.tr_at( fdest ).is_null() )
10115 );
10116
10117 const furn_t furntype = m.furn( fpos ).obj();
10118 const int src_items = m.i_at( fpos ).size();
10119 const int dst_items = m.i_at( fdest ).size();
10120
10121 const bool only_liquid_items = std::all_of( m.i_at( fdest ).begin(), m.i_at( fdest ).end(),
10122 [&]( item & liquid_item ) {
10123 return liquid_item.made_of( LIQUID );
10124 } );
10125
10126 const bool dst_item_ok = !m.has_flag( "NOITEM", fdest ) &&
10127 !m.has_flag( "SWIMMABLE", fdest ) &&
10128 !m.has_flag( "DESTROY_ITEM", fdest );
10129
10130 const bool src_item_ok = m.furn( fpos ).obj().has_flag( "CONTAINER" ) ||
10131 m.furn( fpos ).obj().has_flag( "FIRE_CONTAINER" ) ||
10132 m.furn( fpos ).obj().has_flag( "SEALED" );
10133
10134 const int fire_intensity = m.get_field_intensity( fpos, fd_fire );
10135 time_duration fire_age = m.get_field_age( fpos, fd_fire );
10136
10137 int str_req = furntype.move_str_req;
10138 // Factor in weight of items contained in the furniture.
10139 units::mass furniture_contents_weight = 0_gram;
10140 for( auto &contained_item : m.i_at( fpos ) ) {
10141 furniture_contents_weight += contained_item.weight();
10142 }
10143 str_req += furniture_contents_weight / 4_kilogram;
10144 if( !canmove ) {
10145 // TODO: What is something?
10146 add_msg( _( "The %s collides with something." ), furntype.name() );
10147 u.moves -= 50;
10148 return true;
10149 ///\EFFECT_STR determines ability to drag furniture
10150 } else if( str_req > u.get_str() &&
10151 one_in( std::max( 20 - str_req - u.get_str(), 2 ) ) ) {
10152 add_msg( m_bad, _( "You strain yourself trying to move the heavy %s!" ),
10153 furntype.name() );
10154 u.moves -= 100;
10155 u.mod_pain( 1 ); // Hurt ourselves.
10156 return true; // furniture and or obstacle wins.
10157 } else if( !src_item_ok && !only_liquid_items && dst_items > 0 ) {
10158 add_msg( _( "There's stuff in the way." ) );
10159 u.moves -= 50;
10160 return true;
10161 }
10162
10163 u.moves -= str_req * 10;
10164 // Additional penalty if we can't comfortably move it.
10165 if( str_req > u.get_str() ) {
10166 int move_penalty = std::pow( str_req, 2.0 ) + 100.0;
10167 if( move_penalty <= 1000 ) {
10168 if( u.get_str() >= str_req - 3 ) {
10169 u.moves -= std::max( 3000, move_penalty * 10 );
10170 add_msg( m_bad, _( "The %s is really heavy!" ), furntype.name() );
10171 if( one_in( 3 ) ) {
10172 add_msg( m_bad, _( "You fail to move the %s." ), furntype.name() );
10173 return true;
10174 }
10175 } else {
10176 u.moves -= 100;
10177 add_msg( m_bad, _( "The %s is too heavy for you to budge." ), furntype.name() );
10178 return true;
10179 }
10180 }
10181 u.moves -= move_penalty;
10182 if( move_penalty > 500 ) {
10183 add_msg( _( "Moving the heavy %s is taking a lot of time!" ),
10184 furntype.name() );
10185 } else if( move_penalty > 200 ) {
10186 if( one_in( 3 ) ) { // Nag only occasionally.
10187 add_msg( _( "It takes some time to move the heavy %s." ),
10188 furntype.name() );
10189 }
10190 }
10191 }
10193 _( "a scraping noise." ), true, "misc", "scraping" );
10194
10196 ( tripoint_abs_ms( m.getabs( fpos ) ) );
10197
10198 // Actually move the furniture.
10199 m.furn_set( fdest, m.furn( fpos ), atd ? atd->clone() : nullptr );
10200 m.furn_set( fpos, f_null );
10201
10202 if( fire_intensity == 1 && !pulling_furniture ) {
10203 m.remove_field( fpos, fd_fire );
10204 m.set_field_intensity( fdest, fd_fire, fire_intensity );
10205 m.set_field_age( fdest, fd_fire, fire_age );
10206 }
10207
10208 // Is there is only liquids on the ground, remove them after moving furniture.
10209 if( dst_items > 0 && only_liquid_items ) {
10210 m.i_clear( fdest );
10211 }
10212
10213 if( src_items > 0 ) { // Move the stuff inside.
10214 if( dst_item_ok && src_item_ok ) {
10215 // Assume contents of both cells are legal, so we can just swap contents.
10216 std::list<item> temp;
10217 std::move( m.i_at( fpos ).begin(), m.i_at( fpos ).end(),
10218 std::back_inserter( temp ) );
10219 m.i_clear( fpos );
10220 for( auto item_iter = m.i_at( fdest ).begin();
10221 item_iter != m.i_at( fdest ).end(); ++item_iter ) {
10222 m.i_at( fpos ).insert( *item_iter );
10223 }
10224 m.i_clear( fdest );
10225 for( auto &cur_item : temp ) {
10226 m.i_at( fdest ).insert( cur_item );
10227 }
10228 } else {
10229 add_msg( _( "Stuff spills from the %s!" ), furntype.name() );
10230 }
10231 }
10232
10233 if( shifting_furniture ) {
10234 // We didn't move
10235 tripoint d_sum = u.grab_point + dp;
10236 if( std::abs( d_sum.x ) < 2 && std::abs( d_sum.y ) < 2 ) {
10237 u.grab_point = d_sum; // furniture moved relative to us
10238 } else { // we pushed furniture out of reach
10239 add_msg( _( "You let go of the %s." ), furntype.name() );
10240 u.grab( OBJECT_NONE );
10241 }
10242 return true; // We moved furniture but stayed still.
10243 }
10244
10245 if( pushing_furniture && m.impassable( fpos ) ) {
10246 // Not sure how that chair got into a wall, but don't let player follow.
10247 add_msg( _( "You let go of the %1$s as it slides past %2$s." ),
10248 furntype.name(), m.tername( fdest ) );
10249 u.grab( OBJECT_NONE );
10250 return true;
10251 }
10252
10253 return false;
10254}
virtual int get_str() const
Getters for stats exclusive to characters.
Definition: character.cpp:4080
virtual active_tile_data * clone() const =0
void grab(object_type grab_type, const tripoint &grab_point=tripoint_zero)
Definition: avatar.cpp:642
bool is_empty(const tripoint &p)
Returns true if there is no player, NPC, or monster on the tile and move_cost > 0.
Definition: game.cpp:5161
void insert(const item &newitem) override
Definition: map.cpp:153
void remove_field(const tripoint &p, const field_type_id &field_to_remove)
Remove field entry at xy, ignored if the field entry is not present.
Definition: map.cpp:5443
time_duration set_field_age(const tripoint &p, const field_type_id &type, const time_duration &age, bool isoffset=false)
Set age of field entry at point.
Definition: map.cpp:5317
time_duration get_field_age(const tripoint &p, const field_type_id &type) const
Get the age of a field entry (field_entry::age), if there is no field of that type,...
Definition: map.cpp:5351
int get_field_intensity(const tripoint &p, const field_type_id &type) const
Get the intensity of a field entry (field_entry::intensity), if there is no field of that type,...
Definition: map.cpp:5357
int set_field_intensity(const tripoint &p, const field_type_id &type, int new_intensity, bool isoffset=false)
Set intensity of field entry at point, creating if not present, removing if intensity becomes 0.
Definition: map.cpp:5330
std::string tername(const tripoint &p) const
Definition: map.cpp:1704
void i_clear(const tripoint &p)
Definition: map.cpp:4107
void furn_set(const tripoint &p, const furn_id &new_furniture, cata::poly_serialized< active_tile_data > new_active=nullptr)
Sets the furniture at given position.
Definition: map.cpp:1355
bool has_floor(const tripoint &p) const
Definition: map.cpp:2002
tripoint grab_point
Definition: player.h:641
coords::coord_point< tripoint, coords::origin::abs, coords::ms > tripoint_abs_ms
Definition: coordinates.h:486
@ OBJECT_NONE
Definition: enums.h:187
field_type_id fd_fire
Definition: field_type.cpp:345
furn_id f_null
Definition: mapdata.cpp:1095
template active_tile_data * furn_at< active_tile_data >(const tripoint_abs_ms &)
bool move(avatar &you, map &m, const tripoint &d)
void sound(const tripoint &p, int vol, sound_t category, const std::string &description, bool ambient=false, const std::string &id="", const std::string &variant="default")
Sound at (p) of intensity (vol)
Definition: sounds.cpp:177
int move_str_req
Definition: mapdata.h:505
bool has_flag(const std::string &flag) const
Definition: mapdata.h:415

References _, add_msg(), item_stack::begin(), active_tile_data::clone(), item_stack::end(), f_null, fd_fire, map::furn(), active_tiles::furn_at< active_tile_data >(), map::furn_set(), map::get_field_age(), map::get_field_intensity(), Character::get_str(), map::getabs(), avatar::grab(), player::grab_point, map_data_common_t::has_flag(), map::has_flag(), map::has_floor(), map::has_furn(), map::i_at(), map::i_clear(), map::impassable(), map_stack::insert(), is_empty(), trap::is_null(), m, m_bad, m_info, player::mod_pain(), avatar_action::move(), furn_t::move_str_req, sounds::movement, Creature::moves, map_data_common_t::name(), int_id< T >::obj(), OBJECT_NONE, one_in(), map::passable(), Character::pos(), map::remove_field(), map::set_field_age(), map::set_field_intensity(), item_stack::size(), sounds::sound(), map::tername(), map::tr_at(), u, map::veh_at(), tripoint::x, and tripoint::y.

Referenced by grabbed_move().

◆ grabbed_move()

bool game::grabbed_move ( const tripoint dp)
private

Check for dangerous stuff at dest_loc, return false if the player decides not to step there.

Definition at line 10256 of file game.cpp.

10257{
10258 if( u.get_grab_type() == OBJECT_NONE ) {
10259 return false;
10260 }
10261
10262 if( dp.z != 0 ) {
10263 // No dragging stuff up/down stairs yet!
10264 return false;
10265 }
10266
10267 // vehicle: pulling, pushing, or moving around the grabbed object.
10268 if( u.get_grab_type() == OBJECT_VEHICLE ) {
10269 return grabbed_veh_move( dp );
10270 }
10271
10272 if( u.get_grab_type() == OBJECT_FURNITURE ) {
10273 return grabbed_furn_move( dp );
10274 }
10275
10276 add_msg( m_info, _( "Nothing at grabbed point %d,%d,%d or bad grabbed object type." ),
10278 u.grab( OBJECT_NONE );
10279 return false;
10280}
object_type get_grab_type() const
Definition: avatar.cpp:650
bool grabbed_furn_move(const tripoint &dp)
Definition: game.cpp:10084
bool grabbed_veh_move(const tripoint &dp)
Definition: grab.cpp:21
@ OBJECT_FURNITURE
Definition: enums.h:197
@ OBJECT_VEHICLE
Definition: enums.h:193

References _, add_msg(), avatar::get_grab_type(), avatar::grab(), player::grab_point, grabbed_furn_move(), grabbed_veh_move(), m_info, OBJECT_FURNITURE, OBJECT_NONE, OBJECT_VEHICLE, u, tripoint::x, tripoint::y, and tripoint::z.

Referenced by walk_move().

◆ grabbed_veh_move()

bool game::grabbed_veh_move ( const tripoint dp)
private
Strength determines ability to drag vehicles Strength increases speed of dragging vehicles

Definition at line 21 of file grab.cpp.

22{
23 const optional_vpart_position grabbed_vehicle_vp = m.veh_at( u.pos() + u.grab_point );
24 if( !grabbed_vehicle_vp ) {
25 add_msg( m_info, _( "No vehicle at grabbed point." ) );
27 return false;
28 }
29 vehicle *grabbed_vehicle = &grabbed_vehicle_vp->vehicle();
30 if( !grabbed_vehicle ||
31 !grabbed_vehicle->handle_potential_theft( dynamic_cast<player &>( g->u ) ) ) {
32 return false;
33 }
34 const int grabbed_part = grabbed_vehicle_vp->part_index();
35 for( int part_index = 0; part_index < grabbed_vehicle->part_count(); ++part_index ) {
36 monster *mon = grabbed_vehicle->get_pet( part_index );
37 if( mon != nullptr && mon->has_effect( effect_harnessed ) ) {
38 add_msg( m_info, _( "You cannot move this vehicle whilst your %s is harnessed!" ),
39 mon->get_name() );
41 return false;
42 }
43 }
44 const vehicle *veh_under_player = veh_pointer_or_null( m.veh_at( u.pos() ) );
45 if( grabbed_vehicle == veh_under_player ) {
46 u.grab_point = -dp;
47 return false;
48 }
49
50 tripoint dp_veh = -u.grab_point;
51 const tripoint prev_grab = u.grab_point;
52 tripoint next_grab = u.grab_point;
53
54 bool zigzag = false;
55
56 if( dp == prev_grab ) {
57 // We are pushing in the direction of vehicle
58 dp_veh = dp;
59 } else if( std::abs( dp.x + dp_veh.x ) != 2 && std::abs( dp.y + dp_veh.y ) != 2 ) {
60 // Not actually moving the vehicle, don't do the checks
61 u.grab_point = -( dp + dp_veh );
62 return false;
63 } else if( ( dp.x == prev_grab.x || dp.y == prev_grab.y ) &&
64 next_grab.x != 0 && next_grab.y != 0 ) {
65 // Zig-zag (or semi-zig-zag) pull: player is diagonal to vehicle
66 // and moves away from it, but not directly away
67 dp_veh.x = dp.x == -dp_veh.x ? 0 : dp_veh.x;
68 dp_veh.y = dp.y == -dp_veh.y ? 0 : dp_veh.y;
69
70 next_grab = -dp_veh;
71 zigzag = true;
72 } else {
73 // We are pulling the vehicle
74 next_grab = -dp;
75 }
76
77 // Make sure the mass and pivot point are correct
78 grabbed_vehicle->invalidate_mass();
79
80 //vehicle movement: strength check
81 int mc = 0;
82 int str_req = grabbed_vehicle->total_mass() / 25_kilogram; //strength required to move vehicle.
83
84 //if vehicle is rollable we modify str_req based on a function of movecost per wheel.
85
86 // Vehicle just too big to grab & move; 41-45 lets folks have a bit of a window
87 // (Roughly 1.1K kg = danger zone; cube vans are about the max)
88 if( str_req > 45 ) {
89 add_msg( m_info, _( "The %s is too bulky for you to move by hand." ),
90 grabbed_vehicle->name );
91 return true; // No shoving around an RV.
92 }
93
94 const auto &wheel_indices = grabbed_vehicle->wheelcache;
95 if( grabbed_vehicle->valid_wheel_config() ) {
96 //determine movecost for terrain touching wheels
97 const tripoint vehpos = grabbed_vehicle->global_pos3();
98 for( int p : wheel_indices ) {
99 const tripoint wheel_pos = vehpos + grabbed_vehicle->part( p ).precalc[0];
100 const int mapcost = m.move_cost( wheel_pos, grabbed_vehicle );
101 mc += str_req / wheel_indices.size() * mapcost;
102 }
103 //set strength check threshold
104 //if vehicle has many or only one wheel (shopping cart), it is as if it had four.
105 if( wheel_indices.size() > 4 || wheel_indices.size() == 1 ) {
106 str_req = mc / 4 + 1;
107 } else {
108 str_req = mc / wheel_indices.size() + 1;
109 }
110 } else {
111 str_req++;
112 //if vehicle has no wheels str_req make a noise.
113 if( str_req <= u.get_str() ) {
114 sounds::sound( grabbed_vehicle->global_pos3(), str_req * 2, sounds::sound_t::movement,
115 _( "a scraping noise." ), true, "misc", "scraping" );
116 }
117 }
118
119 //final strength check and outcomes
120 ///\EFFECT_STR determines ability to drag vehicles
121 if( str_req <= u.get_str() ) {
122 //calculate exertion factor and movement penalty
123 ///\EFFECT_STR increases speed of dragging vehicles
124 u.moves -= 100 * str_req / std::max( 1, u.get_str() );
125 const int ex = dice( 1, 3 ) - 1 + str_req;
126 if( ex > u.get_str() + 1 ) {
127 // Pain and movement penalty if exertion exceeds character strength
128 add_msg( m_bad, _( "You strain yourself to move the %s!" ), grabbed_vehicle->name );
129 u.moves -= 200;
130 u.mod_pain( 1 );
131 } else if( ex >= u.get_str() ) {
132 // Movement is slow if exertion nearly equals character strength
133 add_msg( _( "It takes some time to move the %s." ), grabbed_vehicle->name );
134 u.moves -= 200;
135 }
136 } else {
137 u.moves -= 100;
138 add_msg( m_bad, _( "You lack the strength to move the %s" ), grabbed_vehicle->name );
139 return true;
140 }
141
142 std::string blocker_name = _( "errors in movement code" );
143 const auto get_move_dir = [&]( const tripoint & dir, const tripoint & from ) {
144 tileray mdir;
145
146 mdir.init( dir.xy() );
147 grabbed_vehicle->turn( mdir.dir() - grabbed_vehicle->face.dir() );
148 grabbed_vehicle->face = grabbed_vehicle->turn_dir;
149 grabbed_vehicle->precalc_mounts( 1, mdir.dir(), grabbed_vehicle->pivot_point() );
150 grabbed_vehicle->adjust_zlevel( 1, dp );
151
152 // Grabbed part has to stay at distance 1 to the player
153 // and in roughly the same direction.
154 const tripoint new_part_pos = grabbed_vehicle->global_pos3() +
155 grabbed_vehicle->part( grabbed_part ).precalc[ 1 ];
156 const tripoint expected_pos = u.pos() + dp + from;
157 const tripoint actual_dir = expected_pos - new_part_pos;
158
159 // Set player location to illegal value so it can't collide with vehicle.
160 const tripoint player_prev = u.pos();
162 std::vector<veh_collision> colls;
163 const bool failed = grabbed_vehicle->collision( colls, actual_dir, true );
164 u.setpos( player_prev );
165 if( !colls.empty() ) {
166 blocker_name = colls.front().target_name;
167 }
168 return failed ? tripoint_zero : actual_dir;
169 };
170
171 // First try the move as intended
172 // But if that fails and the move is a zig-zag, try to recover:
173 // Try to place the vehicle in the position player just left rather than "flattening" the zig-zag
174 tripoint final_dp_veh = get_move_dir( dp_veh, next_grab );
175 if( final_dp_veh == tripoint_zero && zigzag ) {
176 final_dp_veh = get_move_dir( -prev_grab, -dp );
177 next_grab = -dp;
178 }
179
180 if( final_dp_veh == tripoint_zero ) {
181 add_msg( _( "The %s collides with %s." ), grabbed_vehicle->name, blocker_name );
182 u.grab_point = prev_grab;
183 return true;
184 }
185
186 u.grab_point = next_grab;
187
188 m.displace_vehicle( *grabbed_vehicle, final_dp_veh );
189
190 if( grabbed_vehicle ) {
191 grabbed_vehicle->shift_zlevel();
192 grabbed_vehicle->check_falling_or_floating();
193 } else {
194 debugmsg( "Grabbed vehicle disappeared" );
195 return false;
196 }
197
198 for( int p : wheel_indices ) {
199 if( one_in( 2 ) ) {
200 tripoint wheel_p = grabbed_vehicle->global_part_pos3( grabbed_part );
201 grabbed_vehicle->handle_trap( wheel_p, p );
202 }
203 }
204
205 return false;
206
207}
bool displace_vehicle(vehicle &veh, const tripoint &dp)
Definition: map.cpp:1114
int move_cost(const tripoint &p, const vehicle *ignored_vehicle=nullptr) const
Calculate the cost to move past the tile at p.
Definition: map.cpp:1775
units::angle dir() const
Definition: tileray.cpp:74
void init(const point &ad)
Definition: tileray.cpp:27
void turn(units::angle deg)
const point & pivot_point() const
Definition: vehicle.cpp:5826
void adjust_zlevel(int idir=0, const tripoint &offset=tripoint_zero)
tripoint global_pos3() const
Definition: vehicle.cpp:3281
void precalc_mounts(int idir, units::angle dir, const point &pivot)
Definition: vehicle.cpp:3150
bool valid_wheel_config() const
Definition: vehicle.cpp:4459
units::mass total_mass() const
Definition: vehicle.cpp:3306
std::vector< int > wheelcache
Definition: vehicle.h:1818
void check_falling_or_floating()
tileray face
Definition: vehicle.h:1948
void invalidate_mass()
Mark mass caches and pivot cache as dirty.
Definition: vehicle.cpp:6968
int part_count() const
Definition: vehicle.cpp:7075
bool collision(std::vector< veh_collision > &colls, const tripoint &dp, bool just_detect, bool bash_floor=false)
monster * get_pet(int p) const
Definition: vehicle.cpp:3262
vehicle_part & part(int part_num)
Definition: vehicle.cpp:7080
void handle_trap(const tripoint &p, int part)
tripoint global_part_pos3(const int &index) const
Get the coordinates of the studied part of the vehicle.
Definition: vehicle.cpp:3286
void shift_zlevel()
units::angle turn_dir
Definition: vehicle.h:1927
static const efftype_id effect_harnessed("harnessed")
static constexpr tripoint tripoint_zero
Definition: point.h:273
int dice(int number, int sides)
Definition: rng.cpp:85
std::array< tripoint, 2 > precalc
mount translated to face.dir [0] and turn_dir [1]
Definition: vehicle.h:371

References _, add_msg(), vehicle::adjust_zlevel(), vehicle::check_falling_or_floating(), vehicle::collision(), debugmsg, dice(), tileray::dir(), map::displace_vehicle(), effect_harnessed, vehicle::face, failed, g, monster::get_name(), vehicle::get_pet(), Character::get_str(), vehicle::global_part_pos3(), vehicle::global_pos3(), avatar::grab(), player::grab_point, vehicle::handle_potential_theft(), vehicle::handle_trap(), Creature::has_effect(), tileray::init(), vehicle::invalidate_mass(), m, m_bad, m_info, player::mod_pain(), map::move_cost(), sounds::movement, Creature::moves, vehicle::name, OBJECT_NONE, one_in(), vehicle::part(), vehicle::part_count(), vehicle::pivot_point(), Character::pos(), vehicle_part::precalc, vehicle::precalc_mounts(), Character::setpos(), vehicle::shift_zlevel(), sounds::sound(), vehicle::total_mass(), tripoint_zero, vehicle::turn(), vehicle::turn_dir, u, vehicle::valid_wheel_config(), map::veh_at(), veh_pointer_or_null(), vehicle::wheelcache, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by grabbed_move().

◆ handle_action()

bool game::handle_action ( )
private

Definition at line 1513 of file handle_action.cpp.

1514{
1515 std::string action;
1516 input_context ctxt;
1518 user_turn current_turn;
1519 // Check if we have an auto-move destination
1520 if( u.has_destination() ) {
1522 if( act == ACTION_NULL ) {
1523 add_msg( m_info, _( "Auto-move canceled" ) );
1525 return false;
1526 }
1527 } else if( u.has_destination_activity() ) {
1528 // starts destination activity after the player successfully reached his destination
1530 return false;
1531 } else {
1532 // No auto-move, ask player for input
1533 ctxt = get_player_input( action );
1534 }
1535
1536 const optional_vpart_position vp = m.veh_at( u.pos() );
1537 bool veh_ctrl = !u.is_dead_state() &&
1538 ( ( vp && vp->vehicle().player_in_control( u ) ) || remoteveh() != nullptr );
1539
1540 // If performing an action with right mouse button, co-ordinates
1541 // of location clicked.
1542 cata::optional<tripoint> mouse_target;
1543
1544 if( uquit == QUIT_WATCH && action == "QUIT" ) {
1545 uquit = QUIT_DIED;
1546 return false;
1547 }
1548
1549 if( act == ACTION_NULL ) {
1551
1552 if( act == ACTION_KEYBINDINGS ) {
1553 // already handled by input context
1554 return false;
1555 }
1556
1557 if( act == ACTION_MAIN_MENU ) {
1558 if( uquit == QUIT_WATCH ) {
1559 return false;
1560 }
1561 // No auto-move actions have or can be set at this point.
1563 destination_preview.clear();
1565 if( act == ACTION_NULL ) {
1566 return false;
1567 }
1568 }
1569
1570 if( act == ACTION_ACTIONMENU ) {
1571 if( uquit == QUIT_WATCH ) {
1572 return false;
1573 }
1574 // No auto-move actions have or can be set at this point.
1576 destination_preview.clear();
1578 if( act == ACTION_NULL ) {
1579 return false;
1580 }
1581#if defined(__ANDROID__)
1582 if( get_option<bool>( "ANDROID_ACTIONMENU_AUTOADD" ) && ctxt.get_category() == "DEFAULTMODE" ) {
1583 add_best_key_for_action_to_quick_shortcuts( act, ctxt.get_category(), false );
1584 }
1585#endif
1586 }
1587
1588 if( act == ACTION_KEYBINDINGS ) {
1590 destination_preview.clear();
1591 act = ctxt.display_menu( true );
1592 if( act == ACTION_NULL ) {
1593 return false;
1594 }
1595 }
1596
1599 }
1600
1601 if( act == ACTION_SELECT || act == ACTION_SEC_SELECT ) {
1602 // Mouse button click
1603 if( veh_ctrl ) {
1604 // No mouse use in vehicle
1605 return false;
1606 }
1607
1608 if( u.is_dead_state() ) {
1609 // do not allow mouse actions while dead
1610 return false;
1611 }
1612
1613 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
1614 if( !mouse_pos ) {
1615 return false;
1616 } else if( !u.sees( *mouse_pos ) ) {
1617 // Not clicked in visible terrain
1618 return false;
1619 }
1620 mouse_target = mouse_pos;
1621
1622 if( act == ACTION_SELECT ) {
1623 // Note: The following has the potential side effect of
1624 // setting auto-move destination state in addition to setting
1625 // act.
1626 if( !try_get_left_click_action( act, *mouse_target ) ) {
1627 return false;
1628 }
1629 } else if( act == ACTION_SEC_SELECT ) {
1630 if( !try_get_right_click_action( act, *mouse_target ) ) {
1631 return false;
1632 }
1633 }
1634 } else if( act != ACTION_TIMEOUT ) {
1635 // act has not been set for an auto-move, so clearing possible
1636 // auto-move destinations. Since initializing an auto-move with
1637 // the mouse may span across multiple actions, we do not clear the
1638 // auto-move destination if the action is only a timeout, as this
1639 // would require the user to double click quicker than the
1640 // timeout delay.
1642 destination_preview.clear();
1643 }
1644 }
1645
1646 if( act == ACTION_NULL ) {
1647 const input_event &&evt = ctxt.get_raw_input();
1648 if( !evt.sequence.empty() ) {
1649 const int ch = evt.get_first_input();
1650 const std::string &&name = inp_mngr.get_keyname( ch, evt.type, true );
1651 if( !get_option<bool>( "NO_UNKNOWN_COMMAND_MSG" ) ) {
1652 add_msg( m_info, _( "Unknown command: \"%s\" (%ld)" ), name, ch );
1653 if( const cata::optional<std::string> hint =
1655 add_msg( m_info, _( "%s at any time to see and edit keybindings relevant to "
1656 "the current context." ),
1657 *hint );
1658 }
1659 }
1660 }
1661 return false;
1662 }
1663
1664 // This has no action unless we're in a special game mode.
1665 gamemode->pre_action( act );
1666
1667 int soffset = get_option<int>( "MOVE_VIEW_OFFSET" );
1668
1669 int before_action_moves = u.moves;
1670
1671 // These actions are allowed while deathcam is active. Registered in game::get_player_input
1672 if( uquit == QUIT_WATCH || !u.is_dead_state() ) {
1673 switch( act ) {
1676 break;
1677
1678 case ACTION_CENTER:
1681 break;
1682
1683 case ACTION_SHIFT_N:
1684 case ACTION_SHIFT_NE:
1685 case ACTION_SHIFT_E:
1686 case ACTION_SHIFT_SE:
1687 case ACTION_SHIFT_S:
1688 case ACTION_SHIFT_SW:
1689 case ACTION_SHIFT_W:
1690 case ACTION_SHIFT_NW: {
1691 static const std::map<action_id, std::pair<point, point>> shift_delta = {
1700 };
1702 shift_delta.at( act ).second * soffset : shift_delta.at( act ).first * soffset;
1703 }
1704 break;
1705
1706 case ACTION_LOOK:
1707 look_around();
1708 break;
1709
1710 case ACTION_KEYBINDINGS:
1711 // already handled by input context
1712 break;
1713
1714 default:
1715 break;
1716 }
1717 }
1718
1719 // actions allowed only while alive
1720 if( !u.is_dead_state() ) {
1721 switch( act ) {
1722 case ACTION_NULL:
1723 case NUM_ACTIONS:
1724 break; // dummy entries
1725 case ACTION_ACTIONMENU:
1726 case ACTION_MAIN_MENU:
1727 case ACTION_KEYBINDINGS:
1728 break; // handled above
1729
1730 case ACTION_TIMEOUT:
1731 if( check_safe_mode_allowed( false ) ) {
1732 u.pause();
1733 }
1734 break;
1735
1736 case ACTION_PAUSE:
1737 if( check_safe_mode_allowed() ) {
1738 u.pause();
1739 }
1740 break;
1741
1742 case ACTION_CYCLE_MOVE:
1744 break;
1745
1746 case ACTION_RESET_MOVE:
1748 break;
1749
1750 case ACTION_TOGGLE_RUN:
1752 break;
1753
1756 break;
1757
1760 break;
1761
1762 case ACTION_MOVE_FORTH:
1764 case ACTION_MOVE_RIGHT:
1766 case ACTION_MOVE_BACK:
1768 case ACTION_MOVE_LEFT:
1770 if( !u.get_value( "remote_controlling" ).empty() &&
1774 } else if( veh_ctrl ) {
1775 // vehicle control uses x for steering and y for ac/deceleration,
1776 // so no rotation needed
1778 } else {
1780 if( auto_travel_mode && !u.is_auto_moving() ) {
1781 for( int i = 0; i < SEEX; i++ ) {
1782 tripoint auto_travel_destination( u.posx() + dest_delta.x * ( SEEX - i ),
1783 u.posy() + dest_delta.y * ( SEEX - i ),
1784 u.posz() );
1786 auto_travel_destination,
1788 u.get_path_avoid() );
1789 if( !destination_preview.empty() ) {
1792 break;
1793 }
1794 }
1797 if( dest_next == point_zero ) {
1799 }
1800 dest_delta = dest_next;
1801 }
1802 if( !avatar_action::move( u, m, dest_delta ) ) {
1803 // auto-move should be canceled due to a failed move or obstacle
1805 }
1806 }
1807 break;
1808 case ACTION_MOVE_DOWN:
1809 if( u.is_mounted() ) {
1810 auto mon = u.mounted_creature.get();
1811 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1812 add_msg( m_info, _( "You can't go down stairs while you're riding." ) );
1813 break;
1814 }
1815 }
1816 if( !u.in_vehicle ) {
1817 vertical_move( -1, false );
1818 } else if( veh_ctrl && vp->vehicle().is_rotorcraft() ) {
1820 }
1821 break;
1822
1823 case ACTION_MOVE_UP:
1824 if( u.is_mounted() ) {
1825 auto mon = u.mounted_creature.get();
1826 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1827 add_msg( m_info, _( "You can't go down stairs while you're riding." ) );
1828 break;
1829 }
1830 }
1831 if( !u.in_vehicle ) {
1832 vertical_move( 1, false );
1833 } else if( veh_ctrl && vp->vehicle().is_rotorcraft() ) {
1835 } else if( veh_ctrl && vp->vehicle().has_part( "ROTOR" ) &&
1836 !vp->vehicle().has_sufficient_rotorlift() ) {
1837 add_msg( m_bad, _( "The rotors struggle to generate enough lift!" ) );
1838 }
1839 break;
1840
1841 case ACTION_OPEN:
1843 add_msg( m_info, _( "You can't open things while you're in your shell." ) );
1844 } else if( u.is_mounted() ) {
1845 add_msg( m_info, _( "You can't open things while you're riding." ) );
1846 } else {
1847 open();
1848 }
1849 break;
1850
1851 case ACTION_CLOSE:
1853 add_msg( m_info, _( "You can't close things while you're in your shell." ) );
1854 } else if( u.is_mounted() ) {
1855 auto mon = u.mounted_creature.get();
1856 if( !mon->has_flag( MF_RIDEABLE_MECH ) ) {
1857 add_msg( m_info, _( "You can't close things while you're riding." ) );
1858 }
1859 } else if( mouse_target ) {
1860 doors::close_door( m, u, *mouse_target );
1861 } else {
1862 close();
1863 }
1864 break;
1865
1866 case ACTION_SMASH:
1867 if( veh_ctrl ) {
1868 handbrake();
1869 } else if( u.has_active_mutation( trait_SHELL2 ) ) {
1870 add_msg( m_info, _( "You can't smash things while you're in your shell." ) );
1871 } else {
1872 smash();
1873 }
1874 break;
1875
1876 case ACTION_EXAMINE:
1878 add_msg( m_info, _( "You can't examine your surroundings while you're in your shell." ) );
1879 } else if( mouse_target ) {
1880 examine( *mouse_target );
1881 } else {
1882 examine();
1883 }
1884 break;
1885
1886 case ACTION_ADVANCEDINV:
1888 add_msg( m_info, _( "You can't move mass quantities while you're in your shell." ) );
1889 } else if( u.is_mounted() ) {
1890 add_msg( m_info, _( "You can't move mass quantities while you're riding." ) );
1891 } else {
1893 }
1894 break;
1895
1896 case ACTION_PICKUP:
1898 add_msg( m_info, _( "You can't pick anything up while you're in your shell." ) );
1899 } else if( u.is_mounted() ) {
1900 add_msg( m_info, _( "You can't pick anything up while you're riding." ) );
1901 } else if( mouse_target ) {
1902 pickup( *mouse_target );
1903 } else {
1904 pickup();
1905 }
1906 break;
1907
1908 case ACTION_PICKUP_FEET:
1910 add_msg( m_info, _( "You can't pick anything up while you're in your shell." ) );
1911 } else {
1912 pickup_feet();
1913 }
1914 break;
1915
1916 case ACTION_GRAB:
1918 add_msg( m_info, _( "You can't grab things while you're in your shell." ) );
1919 } else if( u.is_mounted() ) {
1920 add_msg( m_info, _( "You can't grab things while you're riding." ) );
1921 } else {
1922 grab();
1923 }
1924 break;
1925
1926 case ACTION_HAUL:
1928 add_msg( m_info, _( "You can't haul things while you're in your shell." ) );
1929 } else if( u.is_mounted() ) {
1930 add_msg( m_info, _( "You can't haul things while you're riding." ) );
1931 } else {
1932 haul();
1933 }
1934 break;
1935
1936 case ACTION_BUTCHER:
1938 add_msg( m_info, _( "You can't butcher while you're in your shell." ) );
1939 } else if( u.is_mounted() ) {
1940 add_msg( m_info, _( "You can't butcher while you're riding." ) );
1941 } else {
1942 butcher();
1943 }
1944 break;
1945
1946 case ACTION_CHAT:
1947 chat();
1948 break;
1949
1950 case ACTION_PEEK:
1952 add_msg( m_info, _( "You can't peek around corners while you're in your shell." ) );
1953 } else if( u.is_mounted() ) {
1954 add_msg( m_info, _( "You can't peek around corners while you're riding." ) );
1955 } else {
1956 peek();
1957 }
1958 break;
1959
1960 case ACTION_LIST_ITEMS:
1962 break;
1963
1964 case ACTION_ZONES:
1965 zones_manager();
1966 break;
1967
1968 case ACTION_LOOT:
1969 loot();
1970 break;
1971
1972 case ACTION_INVENTORY:
1974 break;
1975
1976 case ACTION_COMPARE:
1978 break;
1979
1980 case ACTION_ORGANIZE:
1982 break;
1983
1984 case ACTION_USE:
1985 // Shell-users are presumed to be able to mess with their inventories, etc
1986 // while in the shell. Eating, gear-changing, and item use are OK.
1988 break;
1989
1990 case ACTION_USE_WIELDED:
1991 u.use_wielded();
1992 break;
1993
1994 case ACTION_WEAR:
1995 wear();
1996 break;
1997
1998 case ACTION_TAKE_OFF:
1999 takeoff();
2000 break;
2001
2002 case ACTION_EAT:
2003 if( !avatar_action::eat_here( u ) ) {
2005 }
2006 break;
2007
2009 if( !avatar_action::eat_here( u ) ) {
2011 }
2012 break;
2013
2014 case ACTION_READ:
2015 // Shell-users are presumed to have the book just at an opening and read it that way
2016 read();
2017 break;
2018
2019 case ACTION_WIELD:
2020 wield();
2021 break;
2022
2023 case ACTION_PICK_STYLE:
2024 u.martial_arts_data->pick_style( u );
2025 break;
2026
2027 case ACTION_RELOAD_ITEM:
2028 reload_item();
2029 break;
2030
2032 reload_weapon();
2033 break;
2034
2037 break;
2038
2039 case ACTION_UNLOAD:
2041 break;
2042
2043 case ACTION_MEND:
2045 break;
2046
2047 case ACTION_THROW: {
2048 item_location loc;
2049 avatar_action::plthrow( g->u, loc );
2050 break;
2051 }
2052
2053 case ACTION_FIRE:
2054 fire();
2055 break;
2056
2057 case ACTION_CAST_SPELL:
2058 cast_spell();
2059 break;
2060
2061 case ACTION_FIRE_BURST: {
2062 if( u.weapon.gun_set_mode( gun_mode_id( "AUTO" ) ) ) {
2064 }
2065 break;
2066 }
2067
2069 if( u.is_armed() && u.weapon.is_gun() && !u.weapon.is_gunmod() ) {
2070 if( u.weapon.gun_all_modes().size() > 1 ) {
2072 } else {
2073 add_msg( m_info, _( "Your %s has only one firing mode." ), u.weapon.display_name() );
2074 }
2075 }
2076 break;
2077
2079 if( u.is_armed() && u.weapon.is_gun() && !u.weapon.is_gunmod() ) {
2081 }
2082 break;
2083
2084 case ACTION_DROP:
2085 // You CAN drop things to your own tile while in the shell.
2086 drop();
2087 break;
2088
2089 case ACTION_DIR_DROP:
2091 add_msg( m_info, _( "You can't drop things to another tile while you're in your shell." ) );
2092 } else {
2094 }
2095 break;
2096 case ACTION_BIONICS:
2097 u.power_bionics();
2098 break;
2099 case ACTION_MUTATIONS:
2101 break;
2102
2103 case ACTION_SORT_ARMOR:
2104 u.sort_armor();
2105 break;
2106
2107 case ACTION_WAIT:
2108 wait();
2109 break;
2110
2111 case ACTION_CRAFT:
2113 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2114 } else if( u.is_mounted() ) {
2115 add_msg( m_info, _( "You can't craft while you're riding." ) );
2116 } else {
2117 u.craft();
2118 }
2119 break;
2120
2121 case ACTION_RECRAFT:
2123 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2124 } else if( u.is_mounted() ) {
2125 add_msg( m_info, _( "You can't craft while you're riding." ) );
2126 } else {
2127 u.recraft();
2128 }
2129 break;
2130
2131 case ACTION_LONGCRAFT:
2133 add_msg( m_info, _( "You can't craft while you're in your shell." ) );
2134 } else if( u.is_mounted() ) {
2135 add_msg( m_info, _( "You can't craft while you're riding." ) );
2136 } else {
2137 u.long_craft();
2138 }
2139 break;
2140
2141 case ACTION_DISASSEMBLE:
2142 if( u.controlling_vehicle ) {
2143 add_msg( m_info, _( "You can't disassemble items while driving." ) );
2144 } else if( u.is_mounted() ) {
2145 add_msg( m_info, _( "You can't disassemble items while you're riding." ) );
2146 } else {
2147 u.disassemble();
2148 }
2149 break;
2150
2151 case ACTION_CONSTRUCT:
2152 if( u.in_vehicle ) {
2153 add_msg( m_info, _( "You can't construct while in a vehicle." ) );
2154 } else if( u.has_active_mutation( trait_SHELL2 ) ) {
2155 add_msg( m_info, _( "You can't construct while you're in your shell." ) );
2156 } else if( u.is_mounted() ) {
2157 add_msg( m_info, _( "You can't construct while you're riding." ) );
2158 } else {
2159 construction_menu( false );
2160 }
2161 break;
2162
2163 case ACTION_SLEEP:
2164 if( veh_ctrl ) {
2165 add_msg( m_info, _( "Vehicle control has moved, %s" ),
2166 press_x( ACTION_CONTROL_VEHICLE, _( "new binding is " ),
2167 _( "new default binding is '^'." ) ) );
2168 } else {
2169 sleep();
2170 }
2171 break;
2172
2175 add_msg( m_info, _( "You can't operate a vehicle while you're in your shell." ) );
2176 } else if( u.is_mounted() ) {
2177 u.dismount();
2178 } else {
2180 }
2181 break;
2182
2185 add_msg( m_info, auto_travel_mode ? _( "Auto travel mode ON!" ) : _( "Auto travel mode OFF!" ) );
2186 break;
2187
2189 if( safe_mode == SAFE_MODE_OFF ) {
2191 mostseen = 0;
2192 add_msg( m_info, _( "Safe mode ON!" ) );
2193 } else {
2196 add_msg( m_info, get_option<bool>( "AUTOSAFEMODE" )
2197 ? _( "Safe mode OFF! (Auto safe mode still enabled!)" ) : _( "Safe mode OFF!" ) );
2198 }
2202 }
2203 break;
2204
2206 auto &autosafemode_option = get_options().get_option( "AUTOSAFEMODE" );
2207 add_msg( m_info, autosafemode_option.value_as<bool>()
2208 ? _( "Auto safe mode OFF!" ) : _( "Auto safe mode ON!" ) );
2209 autosafemode_option.setNext();
2210 break;
2211 }
2212
2214 if( safe_mode == SAFE_MODE_STOP ) {
2215 add_msg( m_info, _( "Ignoring enemy!" ) );
2216 for( auto &elem : u.get_mon_visible().new_seen_mon ) {
2217 monster &critter = *elem;
2218 critter.ignoring = rl_dist( u.pos(), critter.pos() );
2219 }
2221 } else if( u.has_effect( effect_laserlocked ) ) {
2222 if( u.has_trait( trait_PROF_CHURL ) ) {
2223 add_msg( m_warning, _( "You make the sign of the cross." ) );
2224 } else {
2225 add_msg( m_info, _( "Ignoring laser targeting!" ) );
2226 }
2229 }
2230 break;
2231
2233 if( safe_mode == SAFE_MODE_STOP && !get_safemode().empty() ) {
2235 add_msg( m_info, _( "Creature whitelisted: %s" ), get_safemode().lastmon_whitelist );
2237 mostseen = 0;
2238 } else {
2239 get_safemode().show();
2240 }
2241 break;
2242
2243 case ACTION_SUICIDE:
2244 if( query_yn( _( "Commit suicide?" ) ) ) {
2245 if( query_yn( _( "REALLY commit suicide?" ) ) ) {
2246 u.moves = 0;
2247 u.place_corpse();
2249 }
2250 }
2251 break;
2252
2253 case ACTION_SAVE:
2254 if( query_yn( _( "Save and quit?" ) ) ) {
2255 if( save() ) {
2256 u.moves = 0;
2257 uquit = QUIT_SAVED;
2258 }
2259 }
2260 break;
2261
2262 case ACTION_QUICKSAVE:
2263 quicksave();
2264 return false;
2265
2266 case ACTION_QUICKLOAD:
2267 quickload();
2268 return false;
2269
2270 case ACTION_PL_INFO:
2272 break;
2273
2274 case ACTION_MAP:
2276 break;
2277
2278 case ACTION_SKY:
2279 if( m.is_outside( u.pos() ) ) {
2281 } else {
2282 add_msg( m_info, _( "You can't see the sky from here." ) );
2283 }
2284 break;
2285
2286 case ACTION_MISSIONS:
2287 list_missions();
2288 break;
2289
2290 case ACTION_SCORES:
2292 break;
2293
2294 case ACTION_FACTIONS:
2295 faction_manager_ptr->display();
2296 break;
2297
2298 case ACTION_MORALE:
2299 u.disp_morale();
2300 break;
2301
2302 case ACTION_MESSAGES:
2304 break;
2305
2306 case ACTION_HELP:
2308 break;
2309
2310 case ACTION_OPTIONS:
2311 get_options().show( true );
2312 break;
2313
2314 case ACTION_AUTOPICKUP:
2316 break;
2317
2318 case ACTION_AUTONOTES:
2320 break;
2321
2322 case ACTION_SAFEMODE:
2323 get_safemode().show();
2324 break;
2325
2326 case ACTION_COLOR:
2327 all_colors.show_gui();
2328 break;
2329
2330 case ACTION_WORLD_MODS:
2331 world_generator->show_active_world_mods( world_generator->active_world->active_mod_order );
2332 break;
2333
2334 case ACTION_DEBUG:
2336 break; //don't do anything when sharing and not debugger
2337 }
2339 break;
2340
2343 break;
2344
2347 break;
2348
2351 break;
2352
2355 break;
2356
2358 get_options().get_option( "AUTO_FEATURES" ).setNext();
2359 get_options().save();
2360 //~ Auto Features are now ON/OFF
2361 add_msg( _( "%s are now %s." ),
2362 get_options().get_option( "AUTO_FEATURES" ).getMenuText(),
2363 get_option<bool>( "AUTO_FEATURES" ) ? _( "ON" ) : _( "OFF" ) );
2364 break;
2365
2367 get_options().get_option( "AUTO_PULP_BUTCHER" ).setNext();
2368 get_options().save();
2369 //~ Auto Pulp/Pulp Adjacent/Butcher is now set to x
2370 add_msg( _( "%s is now set to %s." ),
2371 get_options().get_option( "AUTO_PULP_BUTCHER" ).getMenuText(),
2372 get_options().get_option( "AUTO_PULP_BUTCHER" ).getValueName() );
2373 break;
2374
2376 get_options().get_option( "AUTO_MINING" ).setNext();
2377 get_options().save();
2378 //~ Auto Mining is now ON/OFF
2379 add_msg( _( "%s is now %s." ),
2380 get_options().get_option( "AUTO_MINING" ).getMenuText(),
2381 get_option<bool>( "AUTO_MINING" ) ? _( "ON" ) : _( "OFF" ) );
2382 break;
2383
2385 if( g->u.get_value( "THIEF_MODE" ) == "THIEF_ASK" ) {
2386 u.set_value( "THIEF_MODE", "THIEF_HONEST" );
2387 u.set_value( "THIEF_MODE_KEEP", "YES" );
2388 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2389 add_msg( _( "You will not pick up other peoples belongings." ) );
2390 } else if( g->u.get_value( "THIEF_MODE" ) == "THIEF_HONEST" ) {
2391 u.set_value( "THIEF_MODE", "THIEF_STEAL" );
2392 u.set_value( "THIEF_MODE_KEEP", "YES" );
2393 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2394 add_msg( _( "You will pick up also those things that belong to others!" ) );
2395 } else if( g->u.get_value( "THIEF_MODE" ) == "THIEF_STEAL" ) {
2396 u.set_value( "THIEF_MODE", "THIEF_ASK" );
2397 u.set_value( "THIEF_MODE_KEEP", "NO" );
2398 //~ Thief mode cycled between THIEF_ASK/THIEF_HONEST/THIEF_STEAL
2399 add_msg( _( "You will be reminded not to steal." ) );
2400 } else {
2401 // ERROR
2402 add_msg( _( "THIEF_MODE CONTAINED BAD VALUE [ %s ]!" ), g->u.get_value( "THIEF_MODE" ) );
2403 }
2404 break;
2405
2407 get_options().get_option( "AUTO_FORAGING" ).setNext();
2408 get_options().save();
2409 //~ Auto Foraging is now set to x
2410 add_msg( _( "%s is now set to %s." ),
2411 get_options().get_option( "AUTO_FORAGING" ).getMenuText(),
2412 get_options().get_option( "AUTO_FORAGING" ).getValueName() );
2413 break;
2414
2416 get_options().get_option( "AUTO_PICKUP" ).setNext();
2417 get_options().save();
2418 //~ Auto pickup is now set to x
2419 add_msg( _( "%s is now set to %s." ),
2420 get_options().get_option( "AUTO_PICKUP" ).getMenuText(),
2421 get_options().get_option( "AUTO_PICKUP" ).getValueName() );
2422 break;
2423
2426 break; //don't do anything when sharing and not debugger
2427 }
2428 display_scent();
2429 break;
2430
2433 break; //don't do anything when sharing and not debugger
2434 }
2435 display_scent();
2436 break;
2437
2440 break; //don't do anything when sharing and not debugger
2441 }
2443 break;
2446 break; //don't do anything when sharing and not debugger
2447 }
2449 break;
2452 break; //don't do anything when sharing and not debugger
2453 }
2455 break;
2456
2459 break; //don't do anything when sharing and not debugger
2460 }
2462 break;
2463
2466 break; //don't do anything when sharing and not debugger
2467 }
2469 break;
2470
2473 break; //don't do anything when sharing and not debugger
2474 }
2476 break;
2477
2479 g->debug_submap_grid_overlay = !g->debug_submap_grid_overlay;
2480 break;
2481
2484 break;
2485
2488 break; //don't do anything when sharing and not debugger
2489 }
2491 if( debug_mode ) {
2492 add_msg( m_info, _( "Debug mode ON!" ) );
2493 } else {
2494 add_msg( m_info, _( "Debug mode OFF!" ) );
2495 }
2496 break;
2497
2498 case ACTION_ZOOM_IN:
2499 zoom_in();
2501 break;
2502
2503 case ACTION_ZOOM_OUT:
2504 zoom_out();
2506 break;
2507
2508 case ACTION_ITEMACTION:
2510 break;
2511
2512 case ACTION_AUTOATTACK:
2514 break;
2515
2516 default:
2517 break;
2518 }
2519 }
2520 if( act != ACTION_TIMEOUT ) {
2521 u.mod_moves( -current_turn.moves_elapsed() );
2522 }
2523 gamemode->post_action( act );
2524
2525 u.movecounter = ( !u.is_dead_state() ? ( before_action_moves - u.moves ) : 0 );
2526 dbg( DL::Info ) << string_format( "%s: [%d] %d - %d = %d", action_ident( act ),
2527 to_turn<int>( calendar::turn ), before_action_moves, u.movecounter, u.moves );
2528 return ( !u.is_dead_state() );
2529}
cata::optional< std::string > press_x_if_bound(action_id act)
Definition: action.cpp:468
bool can_action_change_worldstate(const action_id act)
Lookup whether an action can affect the state of the game world.
Definition: action.cpp:347
action_id look_up_action(const std::string &ident)
Lookup an action ID by its unique string identifier.
Definition: action.cpp:417
action_id handle_main_menu()
Show in-game main menu.
Definition: action.cpp:939
point get_delta_from_movement_action(const action_id act, const iso_rotate rot)
Definition: action.cpp:506
action_id handle_action_menu()
Show the action menu.
Definition: action.cpp:653
@ ACTION_SAFEMODE
Open safemode manager.
Definition: action.h:265
@ ACTION_PEEK
Peek through something (e.g.
Definition: action.h:121
@ ACTION_OPEN
Open an item (e.g.
Definition: action.h:99
@ ACTION_CRAFT
Open crafting menu.
Definition: action.h:199
@ ACTION_DROP
Open the drop-item menu.
Definition: action.h:181
@ ACTION_READ
Open the read menu.
Definition: action.h:153
@ ACTION_TOGGLE_AUTO_PICKUP
Turn auto pickup on/off.
Definition: action.h:309
@ ACTION_MOVE_BACK_LEFT
Move towards bottom-left of screen / decelerate and steer left.
Definition: action.h:51
@ ACTION_ZOOM_IN
Zoom view out.
Definition: action.h:287
@ ACTION_EAT
Open the default consume item menu.
Definition: action.h:149
@ ACTION_SMASH
Smash something.
Definition: action.h:103
@ ACTION_ADVANCEDINV
Open the advanced inventory screen.
Definition: action.h:135
@ ACTION_QUICKSAVE
Quicksave the game.
Definition: action.h:227
@ ACTION_HELP
Display help screen.
Definition: action.h:253
@ ACTION_MESSAGES
Display messages screen.
Definition: action.h:251
@ ACTION_ZONES
Open the zone manager.
Definition: action.h:125
@ ACTION_TOGGLE_PIXEL_MINIMAP
Turn pixel minimap on/off.
Definition: action.h:293
@ ACTION_USE
Open the use menu.
Definition: action.h:141
@ ACTION_QUICKLOAD
Quickload the game.
Definition: action.h:229
@ ACTION_LIST_ITEMS
List items and monsters in a given square.
Definition: action.h:123
@ ACTION_DEBUG
Open debug menu.
Definition: action.h:277
@ ACTION_OPTIONS
Display options window.
Definition: action.h:259
@ ACTION_MOVE_FORTH
Move towards top of screen / accelerate.
Definition: action.h:41
@ ACTION_PICK_STYLE
Open the martial-arts style menu.
Definition: action.h:157
@ ACTION_CONSTRUCT
Open construct menu.
Definition: action.h:205
@ ACTION_MOVE_FORTH_RIGHT
Move towards top-right of screen / accelerate and steer right.
Definition: action.h:43
@ ACTION_SORT_ARMOR
Open the armor sorting menu.
Definition: action.h:189
@ ACTION_OPEN_CONSUME
Open the custom consume item menu.
Definition: action.h:151
@ ACTION_MORALE
Display morale effects screen.
Definition: action.h:249
@ ACTION_NULL
Invalid action used for various lookup errors.
Definition: action.h:24
@ ACTION_RESET_MOVE
Reset movement mode to walk
Definition: action.h:63
@ ACTION_CHAT
Chat with something.
Definition: action.h:117
@ ACTION_RELOAD_WIELDED
Attempt to reload wielded object.
Definition: action.h:163
@ ACTION_MOVE_DOWN
Descend a staircase.
Definition: action.h:57
@ ACTION_MISSIONS
Display missions screen.
Definition: action.h:243
@ ACTION_AUTONOTES
Open autonotes manager.
Definition: action.h:263
@ ACTION_WIELD
Open the wield menu.
Definition: action.h:155
@ ACTION_THROW
Open the throw menu.
Definition: action.h:169
@ ACTION_TOGGLE_AUTO_MINING
Turn auto mining on/off.
Definition: action.h:305
@ ACTION_INVENTORY
Open the primary inventory screen.
Definition: action.h:133
@ ACTION_TOGGLE_AUTOSAFE
Turn automatic triggering of safemode on/off.
Definition: action.h:217
@ ACTION_OPEN_MOVEMENT
Open movement mode menu.
Definition: action.h:69
@ ACTION_COMPARE
Open the item compare screen.
Definition: action.h:137
@ ACTION_SCORES
Display scores screen.
Definition: action.h:245
@ ACTION_BUTCHER
Butcher or disassemble objects in current square.
Definition: action.h:115
@ ACTION_SEC_SELECT
Click on a point with secondary mouse button (usually right button)
Definition: action.h:31
@ ACTION_TOGGLE_CROUCH
Toggle crouch on/off.
Definition: action.h:67
@ ACTION_TOGGLE_HOUR_TIMER
Toggle timing of the game hours.
Definition: action.h:325
@ ACTION_SELECT
Click on a point with primary mouse button (usually left button)
Definition: action.h:29
@ ACTION_MAIN_MENU
Display main menu.
Definition: action.h:255
@ ACTION_DISPLAY_SUBMAP_GRID
Toggle submap grid overlay.
Definition: action.h:323
@ ACTION_WAIT
Open wait menu.
Definition: action.h:197
@ ACTION_ACTIONMENU
Open the action menu.
Definition: action.h:289
@ ACTION_DISASSEMBLE
Open disassemble menu.
Definition: action.h:207
@ ACTION_LOOT
Sort out the loot.
Definition: action.h:127
@ ACTION_TOGGLE_FULLSCREEN
Toggle full-screen mode.
Definition: action.h:275
@ ACTION_MAP
Display over-map.
Definition: action.h:239
@ ACTION_MEND
Open the mending menu (e.g.
Definition: action.h:167
@ ACTION_TOGGLE_THIEF_MODE
Toggle permanent attitude to stealing.
Definition: action.h:219
@ ACTION_USE_WIELDED
Use currently wielded item.
Definition: action.h:143
@ ACTION_PL_INFO
Display player status screen.
Definition: action.h:237
@ ACTION_DISPLAY_SCENT_TYPE
Toggle scent type map.
Definition: action.h:281
@ ACTION_TOGGLE_AUTO_FORAGING
Turn auto foraging on/off.
Definition: action.h:307
@ ACTION_FIRE_BURST
Burst-fire the current weapon.
Definition: action.h:173
@ ACTION_BIONICS
Open the bionics menu.
Definition: action.h:185
@ ACTION_CONTROL_VEHICLE
Open vehicle control menu.
Definition: action.h:211
@ ACTION_SAVE
Save the game and quit.
Definition: action.h:225
@ ACTION_MOVE_UP
Ascend a staircase.
Definition: action.h:59
@ ACTION_TOGGLE_PANEL_ADM
Turn admin panel on/off.
Definition: action.h:295
@ ACTION_TOGGLE_AUTO_PULP_BUTCHER
Change auto pulp/butcher mode.
Definition: action.h:303
@ ACTION_TOGGLE_AUTO_TRAVEL_MODE
Turn auto travel mode on/off.
Definition: action.h:213
@ ACTION_COLOR
Open color manager.
Definition: action.h:267
@ ACTION_TIMEOUT
Input timeout.
Definition: action.h:39
@ ACTION_TOGGLE_RUN
Toggle run on/off.
Definition: action.h:65
@ ACTION_FACTIONS
Display factions screen.
Definition: action.h:247
@ ACTION_GRAB
Grab or let go of an object.
Definition: action.h:111
@ ACTION_MOVE_BACK
Move towards bottom of screen / decelerate.
Definition: action.h:49
@ ACTION_CAST_SPELL
Cast a spell (only if any spells are known)
Definition: action.h:179
@ ACTION_DIR_DROP
Drop items in a given direction.
Definition: action.h:183
@ ACTION_AUTOATTACK
Auto select and attack hostile creature within range.
Definition: action.h:191
@ ACTION_CYCLE_MOVE
Cycle run/walk/crouch mode.
Definition: action.h:61
@ ACTION_SKY
Show sky state for trying to predict weather.
Definition: action.h:241
@ ACTION_FIRE
Fire the wielded weapon, or open fire menu if none.
Definition: action.h:171
@ ACTION_PAUSE
Pause an on-going activity.
Definition: action.h:37
@ ACTION_MOVE_BACK_RIGHT
Move towards bottom-right of screen / decelerate and steer right.
Definition: action.h:47
@ ACTION_MUTATIONS
Open the mutations menu.
Definition: action.h:187
@ ACTION_HAUL
Haul pile of items, or let go of them.
Definition: action.h:113
@ ACTION_MOVE_RIGHT
Move / steer right.
Definition: action.h:45
@ ACTION_SLEEP
Open sleep menu.
Definition: action.h:209
@ ACTION_ITEMACTION
Open the item uses menu.
Definition: action.h:291
@ ACTION_MOVE_LEFT
Move / steer left.
Definition: action.h:53
@ ACTION_SELECT_DEFAULT_AMMO
Change default ammo for current weapon.
Definition: action.h:177
@ ACTION_AUTOPICKUP
Open autopickup manager.
Definition: action.h:261
@ ACTION_SUICIDE
Commit suicide.
Definition: action.h:231
@ NUM_ACTIONS
Not an action, serves as count of enumerated actions.
Definition: action.h:327
@ ACTION_ZOOM_OUT
Zoom view in.
Definition: action.h:285
@ ACTION_SELECT_FIRE_MODE
Change fire mode of the current weapon.
Definition: action.h:175
@ ACTION_UNLOAD
Open the unload item (e.g.
Definition: action.h:165
@ ACTION_RECRAFT
Repeat last craft command.
Definition: action.h:201
@ ACTION_TAKE_OFF
Open the take-off clothing selection menu.
Definition: action.h:147
@ ACTION_PICKUP_FEET
Pick up items from current square.
Definition: action.h:109
@ ACTION_TOGGLE_AUTO_FEATURES
Turn auto features on/off.
Definition: action.h:301
@ ACTION_WORLD_MODS
Open active world mods.
Definition: action.h:269
@ ACTION_TOGGLE_DEBUG_MODE
Toggle debug mode.
Definition: action.h:283
@ ACTION_ORGANIZE
Swap inventory letters.
Definition: action.h:139
@ ACTION_MOVE_FORTH_LEFT
Move towards top-left of screen / accelerate and steer left.
Definition: action.h:55
@ ACTION_RELOAD_TILESET
Reload current tileset.
Definition: action.h:299
@ ACTION_CLOSE
Close an item (e.g.
Definition: action.h:101
@ ACTION_RELOAD_WEAPON
Attempt to reload wielded weapon, then fall back to the load item select menu.
Definition: action.h:161
@ ACTION_RELOAD_ITEM
Open the load item (e.g.
Definition: action.h:159
@ ACTION_PICKUP
Pick up items from current/adjacent squares.
Definition: action.h:107
@ ACTION_LONGCRAFT
Open batch crafting menu.
Definition: action.h:203
@ ACTION_WEAR
Open the wear clothing selection menu.
Definition: action.h:145
void create_advanced_inv()
auto_notes::auto_note_settings & get_auto_notes_settings()
Definition: auto_note.cpp:386
auto_pickup::player_settings & get_auto_pickup()
Definition: auto_pickup.cpp:38
bool tile_iso
Using isometric tileset.
bool debug_mode
Extended debugging mode, can be toggled during game.
bool has_active_mutation(const trait_id &b) const
Definition: mutation.cpp:367
pimpl< character_martial_arts > martial_arts_data
Definition: character.h:1533
bool has_active_item(const itype_id &id) const
Whether the player carries an active item of the given item type.
Definition: character.cpp:2564
void place_corpse()
std::set< tripoint > get_path_avoid() const override
Returns a set of points we do not want to path through.
Definition: character.cpp:9960
bool has_destination_activity() const
bool is_auto_moving() const
void start_destination_activity()
action_id get_next_auto_move_direction()
const pathfinding_settings & get_pathfinding_settings() const override
Returns settings for pathfinding.
Definition: character.cpp:9974
bool is_armed() const
Returns true if the character is wielding something.
Definition: melee.cpp:145
void dismount()
Definition: character.cpp:1247
item weapon
Definition: character.h:1529
void set_value(const std::string &key, const std::string &value)
Definition: creature.cpp:1331
std::string get_value(const std::string &key) const
Definition: creature.cpp:1341
void mod_moves(int nmoves)
Definition: creature.cpp:1408
void cycle_move_mode()
Definition: avatar.cpp:1173
void toggle_map_memory()
Definition: avatar.cpp:119
void toggle_crouch_mode()
Definition: avatar.cpp:1157
void toggle_run_mode()
Definition: avatar.cpp:1148
void disp_morale()
Provides the window and detailed morale data.
Definition: avatar.cpp:988
void reset_move_mode()
Definition: avatar.cpp:1166
void item_action_menu()
void display_radiation()
Definition: game.cpp:11812
void list_missions()
Definition: mission_ui.cpp:22
input_context get_player_input(std::string &action)
bool try_get_left_click_action(action_id &act, const tripoint &mouse_target)
Definition: game.cpp:2618
void wield()
Definition: game.cpp:9119
void set_safe_mode(safe_mode_type mode)
Definition: game.cpp:9192
void reload_wielded(bool prompt=false)
Definition: game.cpp:8952
cata::optional< tripoint > look_around()
Definition: game.cpp:6860
void pickup_feet()
Definition: game.cpp:5917
void zones_manager()
Definition: game.cpp:6385
int turnssincelastmon
Definition: game.h:1069
void display_visibility()
Definition: game.cpp:11726
void display_scent()
Definition: game.cpp:11691
bool save()
Returns false if saving failed.
Definition: game.cpp:3111
void butcher()
Definition: game.cpp:8579
void display_temperature()
Definition: game.cpp:11712
bool auto_travel_mode
Definition: game.h:1066
void zoom_out()
Definition: game.cpp:7327
void toggle_pixel_minimap()
Definition: game.cpp:510
void toggle_debug_hour_timer()
Definition: game.cpp:11758
void display_transparency()
Definition: game.cpp:11819
void list_items_monsters()
Definition: game.cpp:7504
void chat()
Definition: npctalk.cpp:394
void quickload()
Definition: game.cpp:11854
void pickup()
Definition: game.cpp:5895
void vertical_move(int z, bool force, bool peeking=false)
Moves the player vertically.
Definition: game.cpp:10539
void open_consume_item_menu()
void display_lighting()
Definition: game.cpp:11786
void control_vehicle()
Definition: game.cpp:5465
void peek()
Definition: game.cpp:5924
void drop()
Definition: game.cpp:8318
bool try_get_right_click_action(action_id &act, const tripoint &mouse_target)
Definition: game.cpp:2646
void reload_weapon(bool try_everything=true)
Definition: game.cpp:8962
bool check_safe_mode_allowed(bool repeat_safe_mode_warnings=true)
Check whether movement is allowed according to safe mode settings.
Definition: game.cpp:9130
void zoom_in()
Definition: game.cpp:7339
void toggle_fullscreen()
Definition: game.cpp:500
void display_vehicle_ai()
Definition: game.cpp:11719
void reload_item()
Definition: game.cpp:8938
void reload_tileset()
Definition: game.cpp:521
void mark_main_ui_adaptor_resize() const
Definition: game.cpp:3359
void drop_in_direction()
Definition: game.cpp:8323
void display_help()
Definition: help.cpp:140
cata::optional< tripoint > get_coordinates(const catacurses::window &capture_win_)
Get the coordinates associated with the last mouse click (if any).
Definition: input.cpp:1338
input_event get_raw_input()
Temporary method to retrieve the raw input received, so that input_contexts can be used in screens wh...
Definition: input.cpp:1299
action_id display_menu(bool permit_execute_action=false)
Displays the possible actions in the current context and their keybindings.
Definition: input.cpp:999
std::string get_keyname(int ch, input_event_t inp_type, bool portable=false) const
Get the key name associated with the given keyboard keycode.
Definition: input.cpp:415
bool is_gun() const
Can this item be used to perform a ranged attack?
Definition: item.cpp:6361
void gun_cycle_mode()
Switch to the next available firing mode.
Definition: item.cpp:7752
std::string display_name(unsigned int quantity=1) const
Returns the item name and the charges or contained charges (if the item can have charges at all).
Definition: item.cpp:4700
bool is_gunmod() const
Definition: item.cpp:6391
std::map< gun_mode_id, gun_mode > gun_all_modes() const
Get all possible modes for this gun inclusive of any attached gunmods.
Definition: item.cpp:7671
bool gun_set_mode(const gun_mode_id &mode)
Try to set the mode for a gun, returning false if no such mode is possible.
Definition: item.cpp:7743
bool is_outside(const tripoint &p) const
Definition: map.cpp:2558
std::vector< tripoint > route(const tripoint &f, const tripoint &t, const pathfinding_settings &settings, const std::set< tripoint > &pre_closed={{ }}) const
Calculate the best path using A*.
const tripoint & pos() const override
Definition: monster.cpp:255
short ignoring
Definition: monster.h:507
cOpt & get_option(const std::string &name)
Definition: options.cpp:3334
std::string show(bool ingame=false, bool world_options_only=false, const std::function< bool()> &on_quit=nullptr)
Definition: options.cpp:2722
void show_adm()
Definition: panels.cpp:2405
void pause()
Definition: player.cpp:651
void craft(const tripoint &loc=tripoint_zero)
Start various types of crafts.
Definition: crafting.cpp:335
void sort_armor()
Draws the UI and handles player input for the armor re-ordering window.
void power_mutations()
Definition: mutation_ui.cpp:89
void use_wielded()
Uses the current wielded weapon.
Definition: player.cpp:3124
int movecounter
Definition: player.h:653
void power_bionics()
Generates and handles the UI for player interaction with installed bionics.
Definition: bionics_ui.cpp:528
void recraft(const tripoint &loc=tripoint_zero)
Definition: crafting.cpp:346
void long_craft(const tripoint &loc=tripoint_zero)
Definition: crafting.cpp:355
void add_rule(const std::string &rule_in, Creature::Attitude attitude_in, int proximity_in, rule_state state_in)
void show()
Definition: safemode_ui.cpp:39
int moves_elapsed()
#define all_colors
Definition: color.h:15
construction_id construction_menu(const bool blueprint)
@ Info
Information (default: enabled).
@ RULE_WHITELISTED
Definition: enums.h:53
@ SAFE_MODE_OFF
Definition: game.h:77
@ QUIT_SAVED
Definition: game.h:70
static void open_movement_mode_menu()
static void smash()
static void open()
#define dbg(x)
static void takeoff()
static void read()
static void wait()
static const efftype_id effect_laserlocked("laserlocked")
static void rcdrive(const point &d)
static void wear()
static void close()
static const bionic_id bio_remote("bio_remote")
static void pldrive(const tripoint &p)
static void haul()
static const trait_id trait_SHELL2("SHELL2")
static const trait_id trait_PROF_CHURL("PROF_CHURL")
static void cast_spell()
static void loot()
static void fire()
static void grab()
static void sleep()
static const itype_id itype_radiocontrol("radiocontrol")
help & get_help()
Definition: help.cpp:30
bool isDebugger()
Definition: mapsharing.cpp:65
bool isCompetitive()
Definition: mapsharing.cpp:35
void use_item(avatar &you, item_location &loc)
bool eat_here(avatar &you)
void autoattack(avatar &you, map &m)
void eat(avatar &you)
Eat food or fuel 'E' (or 'a')
void fire_wielded_weapon(avatar &you)
Checks if the wielded weapon is a gun and can be fired then starts interactive aiming.
void plthrow(avatar &you, item_location loc, const cata::optional< tripoint > &blind_throw_from_pos=cata::nullopt)
void mend(avatar &you, item_location loc)
void unload(avatar &you)
void disp_info(Character &ch)
Handles and displays detailed character info for the '@' screen.
void debug()
void close_door(map &m, Character &who, const tripoint &closep)
Handles deducting moves, printing messages (only non-NPCs cause messages), actually closing it,...
Definition: gates.cpp:256
void compare(player &p, const cata::optional< tripoint > &offset)
void common(avatar &you)
void swap_letters(player &p)
void prompt_select_default_ammo_for(avatar &u, const item &w)
Prompts to select default ammo compatible with provided gun.
Definition: ranged.cpp:3754
void display_visible_weather()
Display overmap like with display() and display the weather that is within line of sight.
void display()
Display overmap centered at the player's position.
options_manager & get_options()
Definition: options.cpp:142
T get_option(const std::string &name)
Definition: options.h:368
static constexpr point point_south_west
Definition: point.h:281
static constexpr point point_north_east
Definition: point.h:277
static constexpr point point_north_west
Definition: point.h:283
An instance of an input, like a keypress etc.
Definition: input.h:95
std::vector< int > sequence
Definition: input.h:101
int get_first_input() const
Definition: input.cpp:100
input_event_t type
Definition: input.h:96
void handbrake()

References _, Creature::A_ANY, achievements_tracker_ptr, act, action, ACTION_ACTIONMENU, ACTION_ADVANCEDINV, ACTION_AUTOATTACK, ACTION_AUTONOTES, ACTION_AUTOPICKUP, ACTION_BIONICS, ACTION_BUTCHER, ACTION_CAST_SPELL, ACTION_CENTER, ACTION_CHAT, ACTION_CLOSE, ACTION_COLOR, ACTION_COMPARE, ACTION_CONSTRUCT, ACTION_CONTROL_VEHICLE, ACTION_CRAFT, ACTION_CYCLE_MOVE, ACTION_DEBUG, ACTION_DIR_DROP, ACTION_DISASSEMBLE, ACTION_DISPLAY_LIGHTING, ACTION_DISPLAY_RADIATION, ACTION_DISPLAY_SCENT, ACTION_DISPLAY_SCENT_TYPE, ACTION_DISPLAY_SUBMAP_GRID, ACTION_DISPLAY_TEMPERATURE, ACTION_DISPLAY_TRANSPARENCY, ACTION_DISPLAY_VEHICLE_AI, ACTION_DISPLAY_VISIBILITY, ACTION_DROP, ACTION_EAT, ACTION_EXAMINE, ACTION_FACTIONS, ACTION_FIRE, ACTION_FIRE_BURST, ACTION_GRAB, ACTION_HAUL, ACTION_HELP, action_ident(), ACTION_IGNORE_ENEMY, ACTION_INVENTORY, ACTION_ITEMACTION, ACTION_KEYBINDINGS, ACTION_LIST_ITEMS, ACTION_LONGCRAFT, ACTION_LOOK, ACTION_LOOT, ACTION_MAIN_MENU, ACTION_MAP, ACTION_MEND, ACTION_MESSAGES, ACTION_MISSIONS, ACTION_MORALE, ACTION_MOVE_BACK, ACTION_MOVE_BACK_LEFT, ACTION_MOVE_BACK_RIGHT, ACTION_MOVE_DOWN, ACTION_MOVE_FORTH, ACTION_MOVE_FORTH_LEFT, ACTION_MOVE_FORTH_RIGHT, ACTION_MOVE_LEFT, ACTION_MOVE_RIGHT, ACTION_MOVE_UP, ACTION_MUTATIONS, ACTION_NULL, ACTION_OPEN, ACTION_OPEN_CONSUME, ACTION_OPEN_MOVEMENT, ACTION_OPTIONS, ACTION_ORGANIZE, ACTION_PAUSE, ACTION_PEEK, ACTION_PICK_STYLE, ACTION_PICKUP, ACTION_PICKUP_FEET, ACTION_PL_INFO, ACTION_QUICKLOAD, ACTION_QUICKSAVE, ACTION_READ, ACTION_RECRAFT, ACTION_RELOAD_ITEM, ACTION_RELOAD_TILESET, ACTION_RELOAD_WEAPON, ACTION_RELOAD_WIELDED, ACTION_RESET_MOVE, ACTION_SAFEMODE, ACTION_SAVE, ACTION_SCORES, ACTION_SEC_SELECT, ACTION_SELECT, ACTION_SELECT_DEFAULT_AMMO, ACTION_SELECT_FIRE_MODE, ACTION_SHIFT_E, ACTION_SHIFT_N, ACTION_SHIFT_NE, ACTION_SHIFT_NW, ACTION_SHIFT_S, ACTION_SHIFT_SE, ACTION_SHIFT_SW, ACTION_SHIFT_W, ACTION_SKY, ACTION_SLEEP, ACTION_SMASH, ACTION_SORT_ARMOR, ACTION_SUICIDE, ACTION_TAKE_OFF, ACTION_THROW, ACTION_TIMEOUT, ACTION_TOGGLE_AUTO_FEATURES, ACTION_TOGGLE_AUTO_FORAGING, ACTION_TOGGLE_AUTO_MINING, ACTION_TOGGLE_AUTO_PICKUP, ACTION_TOGGLE_AUTO_PULP_BUTCHER, ACTION_TOGGLE_AUTO_TRAVEL_MODE, ACTION_TOGGLE_AUTOSAFE, ACTION_TOGGLE_CROUCH, ACTION_TOGGLE_DEBUG_MODE, ACTION_TOGGLE_FULLSCREEN, ACTION_TOGGLE_HOUR_TIMER, ACTION_TOGGLE_MAP_MEMORY, ACTION_TOGGLE_PANEL_ADM, ACTION_TOGGLE_PIXEL_MINIMAP, ACTION_TOGGLE_RUN, ACTION_TOGGLE_SAFEMODE, ACTION_TOGGLE_THIEF_MODE, ACTION_UNLOAD, ACTION_USE, ACTION_USE_WIELDED, ACTION_WAIT, ACTION_WEAR, ACTION_WHITELIST_ENEMY, ACTION_WIELD, ACTION_WORLD_MODS, ACTION_ZONES, ACTION_ZOOM_IN, ACTION_ZOOM_OUT, add_msg(), safemode::add_rule(), all_colors, auto_travel_mode, avatar_action::autoattack(), bio_remote, butcher(), can_action_change_worldstate(), cast_spell(), chat(), check_safe_mode_allowed(), Character::clear_destination(), close(), doors::close_door(), game_menus::inv::common(), game_menus::inv::compare(), construction_menu(), control_vehicle(), Character::controlling_vehicle, player::craft(), create_advanced_inv(), avatar::cycle_move_mode(), dbg, debug_menu::debug(), debug_mode, destination_preview, player::disassemble(), Character::dismount(), character_display::disp_info(), avatar::disp_morale(), ui::omap::display(), help::display_help(), display_lighting(), input_context::display_menu(), Messages::display_messages(), item::display_name(), display_radiation(), display_scent(), display_temperature(), display_transparency(), display_vehicle_ai(), display_visibility(), ui::omap::display_visible_weather(), driving_view_offset, drop(), drop_in_direction(), avatar_action::eat(), avatar_action::eat_here(), effect_laserlocked, examine(), faction_manager_ptr, fire(), avatar_action::fire_wielded_weapon(), g, gamemode, get_auto_notes_settings(), get_auto_pickup(), input_context::get_coordinates(), get_delta_from_movement_action(), input_event::get_first_input(), get_help(), input_manager::get_keyname(), get_kill_tracker(), panel_manager::get_manager(), avatar::get_mon_visible(), Character::get_next_auto_move_direction(), options_manager::get_option(), get_option(), get_options(), Character::get_path_avoid(), Character::get_pathfinding_settings(), get_player_input(), input_context::get_raw_input(), get_safemode(), Creature::get_value(), grab(), item::gun_all_modes(), item::gun_cycle_mode(), item::gun_set_mode(), handbrake(), handle_action_menu(), handle_main_menu(), Character::has_active_bionic(), Character::has_active_item(), Character::has_active_mutation(), Character::has_destination(), Character::has_destination_activity(), Creature::has_effect(), Character::has_trait(), haul(), monster::ignoring, Character::in_vehicle, Info, inp_mngr, Character::is_armed(), Character::is_auto_moving(), player::is_dead_state(), item::is_gun(), item::is_gunmod(), Character::is_mounted(), map::is_outside(), MAP_SHARING::isCompetitive(), MAP_SHARING::isDebugger(), item_action_menu(), itype_radiocontrol, list_items_monsters(), list_missions(), player::long_craft(), look_around(), look_up_action(), loot(), m, m_bad, m_info, m_warning, mark_main_ui_adaptor_resize(), Character::martial_arts_data, avatar_action::mend(), MF_RIDEABLE_MECH, Creature::mod_moves(), mostseen, Character::mounted_creature, avatar_action::move(), player::movecounter, Creature::moves, user_turn::moves_elapsed(), om_direction::name(), monster_visible_info::new_seen_mon, no, cata::nullopt, NUM_ACTIONS, open(), open_consume_item_menu(), open_movement_mode_menu(), player::pause(), peek(), pickup(), pickup_feet(), Character::place_corpse(), pldrive(), avatar_action::plthrow(), point_east, point_north, point_north_east, point_north_west, point_south, point_south_east, point_south_west, point_west, point_zero, Character::pos(), monster::pos(), Character::posx(), Character::posy(), Character::posz(), player::power_bionics(), player::power_mutations(), press_x(), press_x_if_bound(), ranged::prompt_select_default_ammo_for(), query_yn(), quickload(), quicksave(), QUIT_DIED, QUIT_SAVED, QUIT_SUICIDE, QUIT_WATCH, rcdrive(), read(), player::recraft(), reload_item(), reload_tileset(), reload_weapon(), reload_wielded(), remoteveh(), Creature::remove_effect(), avatar::reset_move_mode(), rl_dist(), map::route(), RULE_WHITELISTED, safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAFE_MODE_STOP, safe_mode_warning_logged, save(), options_manager::save(), Character::sees(), SEEX, input_event::sequence, Character::set_destination(), set_safe_mode(), Creature::set_value(), options_manager::cOpt::setNext(), auto_pickup::player_settings::show(), safemode::show(), options_manager::show(), panel_manager::show_adm(), auto_notes::auto_note_settings::show_gui(), show_scores_ui(), sleep(), smash(), player::sort_armor(), Character::start_destination_activity(), stats(), string_format(), game_menus::inv::swap_letters(), takeoff(), tile_iso, avatar::toggle_crouch_mode(), toggle_debug_hour_timer(), toggle_fullscreen(), avatar::toggle_map_memory(), toggle_pixel_minimap(), avatar::toggle_run_mode(), trait_PROF_CHURL, trait_SHELL2, tripoint_above, tripoint_below, try_get_left_click_action(), try_get_right_click_action(), calendar::turn, turnssincelastmon, input_event::type, u, avatar_action::unload(), uquit, avatar_action::use_item(), use_tiles, player::use_wielded(), user_action_counter, map::veh_at(), vertical_move(), player::view_offset, w_terrain, wait(), Character::weapon, wear(), wield(), world_generator, point::x, tripoint::x, point::y, tripoint::y, yes, zones_manager(), zoom_in(), and zoom_out().

Referenced by do_turn().

◆ handle_key_blocking_activity()

void game::handle_key_blocking_activity ( )
private

Definition at line 2057 of file game.cpp.

2058{
2060 const std::string action = ctxt.handle_input( 0 );
2061 bool refresh = true;
2062 if( action == "pause" ) {
2064 cancel_activity_query( _( "Confirm:" ) );
2065 }
2066 } else if( action == "player_data" ) {
2068 } else if( action == "messages" ) {
2070 } else if( action == "help" ) {
2072 } else if( action != "HELP_KEYBINDINGS" ) {
2073 refresh = false;
2074 }
2075 if( refresh ) {
2078 }
2079}
bool cancel_activity_query(const std::string &text)
Asks if the player wants to cancel their activity, and if so cancels it.
Definition: game.cpp:1841
const std::string & handle_input()
Handles input and returns the next action in the queue.
Definition: input.cpp:854
bool interruptable_with_kb
Controls whether this activity can be cancelled with 'pause' action.
void refresh()

References _, action, Character::activity, cancel_activity_query(), character_display::disp_info(), help::display_help(), Messages::display_messages(), get_default_mode_input_context(), get_help(), input_context::handle_input(), player_activity::interruptable_with_kb, ui_manager::redraw(), catacurses::refresh(), refresh_display(), and u.

Referenced by process_voluntary_act_interrupt().

◆ handle_mouseview()

bool game::handle_mouseview ( input_context ctxt,
std::string &  action 
)
private

Definition at line 2325 of file game.cpp.

2326{
2327 cata::optional<tripoint> liveview_pos;
2328
2329 do {
2330 action = ctxt.handle_input();
2331 if( action == "MOUSE_MOVE" ) {
2332 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
2333 if( mouse_pos && ( !liveview_pos || *mouse_pos != *liveview_pos ) ) {
2334 liveview_pos = mouse_pos;
2335 liveview.show( *liveview_pos );
2336 } else if( !mouse_pos ) {
2337 liveview_pos.reset();
2338 liveview.hide();
2339 }
2341 }
2342 } while( action == "MOUSE_MOVE" ); // Freeze animation when moving the mouse
2343
2344 if( action != "TIMEOUT" ) {
2345 // Keyboard event, break out of animation loop
2346 liveview.hide();
2347 return false;
2348 }
2349
2350 // Mouse movement or un-handled key
2351 return true;
2352}
void reset() noexcept
Definition: optional.h:155
void hide()
Definition: live_view.cpp:33
void show(const tripoint &p)
Definition: live_view.cpp:38

References action, input_context::get_coordinates(), input_context::handle_input(), live_view::hide(), liveview, ui_manager::redraw(), cata::optional< T >::reset(), live_view::show(), and w_terrain.

Referenced by get_player_input().

◆ has_gametype()

bool game::has_gametype ( ) const

Definition at line 624 of file game.cpp.

625{
626 return gamemode && gamemode->id() != SGAME_NULL;
627}

References gamemode, and SGAME_NULL.

◆ init_autosave()

void game::init_autosave ( )
private

Definition at line 11826 of file game.cpp.

11827{
11829 last_save_timestamp = time( nullptr );
11830}

References last_save_timestamp, and moves_since_last_save.

Referenced by load(), and start_game().

◆ inv_map_splice()

item_location game::inv_map_splice ( item_filter  filter,
const std::string &  title,
int  radius = 0,
const std::string &  none_message = "" 
)

Custom-filtered menu for inventory and nearby items and those that within specified radius.

Definition at line 391 of file game_inventory.cpp.

393{
395 title, radius, none_message );
396}
static item_location_filter convert_filter(const item_filter &filter)
static item_location inv_internal(player &u, const inventory_selector_preset &preset, const std::string &title, int radius, const std::string &none_message, const std::string &hint=std::string())
std::string title(holiday current_holiday)
Definition: path_info.cpp:330

References convert_filter(), inv_internal(), PATH_INFO::title(), and u.

Referenced by reload_item().

◆ invalidate_main_ui_adaptor()

void game::invalidate_main_ui_adaptor ( ) const

◆ inventory_item_menu()

int game::inventory_item_menu ( item_location  locThisItem,
const std::function< int()> &  startx = []() { return 0; },
const std::function< int()> &  width = []() { return 50; },
inventory_item_menu_positon  position = RIGHT_OF_INFO 
)

Definition at line 2089 of file game.cpp.

2093{
2094 int cMenu = static_cast<int>( '+' );
2095
2096 item &oThisItem = *locThisItem;
2097 if( u.has_item( oThisItem ) ) {
2098#if defined(__ANDROID__)
2099 if( get_option<bool>( "ANDROID_INVENTORY_AUTOADD" ) ) {
2100 add_key_to_quick_shortcuts( oThisItem.invlet, "INVENTORY", false );
2101 }
2102#endif
2103
2104 std::vector<iteminfo> vThisItem;
2105 std::vector<iteminfo> vDummy;
2106
2107 const bool bHPR = get_auto_pickup().has_rule( &oThisItem );
2108 const bool is_wielded = u.is_wielding( oThisItem );
2109 const bool cant_unwield_if_weapon = is_wielded && !u.can_unwield( oThisItem ).success();
2110 const bool cant_unwield_existing_weapon = u.is_armed() && !u.can_unwield( u.weapon ).success();
2111 const bool cant_takeoff_if_worn = u.is_wearing( oThisItem ) &&
2112 !u.can_takeoff( oThisItem ).success();
2113 const bool cant_dispose_of = cant_unwield_if_weapon || cant_takeoff_if_worn;
2114 const bool cant_acquare = cant_unwield_existing_weapon || cant_takeoff_if_worn;
2115 const hint_rating rate_unwield_item = cant_dispose_of ? hint_rating::cant :
2117 const hint_rating rate_wield_item = cant_acquare ? hint_rating::cant :
2119 const hint_rating rate_drop_item = cant_dispose_of ? hint_rating::cant :
2121
2122 uilist action_menu;
2123 action_menu.allow_anykey = true;
2124 const auto addentry = [&]( const char key, const std::string & text, const hint_rating hint ) {
2125 // The char is used as retval from the uilist *and* as hotkey.
2126 action_menu.addentry( key, true, key, text );
2127 auto &entry = action_menu.entries.back();
2128 switch( hint ) {
2129 case hint_rating::cant:
2130 entry.text_color = c_light_gray;
2131 break;
2132 case hint_rating::iffy:
2133 entry.text_color = c_light_red;
2134 break;
2135 case hint_rating::good:
2136 entry.text_color = c_light_green;
2137 break;
2138 }
2139 };
2140 addentry( 'a', pgettext( "action", "activate" ), u.rate_action_use( oThisItem ) );
2141 addentry( 'R', pgettext( "action", "read" ), u.rate_action_read( oThisItem ) );
2142 addentry( 'E', pgettext( "action", "eat" ), u.rate_action_eat( oThisItem ) );
2143 addentry( 'W', pgettext( "action", "wear" ), u.rate_action_wear( oThisItem ) );
2144 if( is_wielded ) {
2145 addentry( 'w', pgettext( "action", "unwield" ), rate_unwield_item );
2146 } else {
2147 addentry( 'w', pgettext( "action", "wield" ), rate_wield_item );
2148 }
2149 addentry( 't', pgettext( "action", "throw" ), rate_drop_item );
2150 addentry( 'c', pgettext( "action", "change side" ), u.rate_action_change_side( oThisItem ) );
2151 addentry( 'T', pgettext( "action", "take off" ), u.rate_action_takeoff( oThisItem ) );
2152 addentry( 'd', pgettext( "action", "drop" ), rate_drop_item );
2153 addentry( 'U', pgettext( "action", "unload" ), u.rate_action_unload( oThisItem ) );
2154 addentry( 'r', pgettext( "action", "reload" ), u.rate_action_reload( oThisItem ) );
2155 addentry( 'p', pgettext( "action", "part reload" ), u.rate_action_reload( oThisItem ) );
2156 addentry( 'm', pgettext( "action", "mend" ), u.rate_action_mend( oThisItem ) );
2157 addentry( 'D', pgettext( "action", "disassemble" ), u.rate_action_disassemble( oThisItem ) );
2158
2159 if( oThisItem.is_favorite ) {
2160 addentry( 'f', pgettext( "action", "unfavorite" ), hint_rating::good );
2161 } else {
2162 addentry( 'f', pgettext( "action", "favorite" ), hint_rating::good );
2163 }
2164
2165 addentry( '=', pgettext( "action", "reassign" ), hint_rating::good );
2166
2167 if( bHPR ) {
2168 addentry( '-', _( "Autopickup" ), hint_rating::iffy );
2169 } else {
2170 addentry( '+', _( "Autopickup" ), hint_rating::good );
2171 }
2172
2173 int iScrollPos = 0;
2174 oThisItem.info( true, vThisItem );
2175
2176 action_menu.w_y_setup = 0;
2177 action_menu.w_x_setup = [&]( const int popup_width ) -> int {
2178 switch( position )
2179 {
2180 default:
2182 return 0;
2183 case LEFT_OF_INFO:
2184 return iStartX() - popup_width;
2185 case RIGHT_OF_INFO:
2186 return iStartX() + iWidth();
2187 case LEFT_TERMINAL_EDGE:
2188 return TERMX - popup_width;
2189 }
2190 };
2191 // Filtering isn't needed, the number of entries is manageable.
2192 action_menu.filtering = false;
2193 // Default menu border color is different, this matches the border of the item info window.
2194 action_menu.border_color = BORDER_COLOR;
2195
2196 item_info_data data( oThisItem.tname(), oThisItem.type_name(), vThisItem, vDummy, iScrollPos );
2197 data.without_getch = true;
2198
2199 catacurses::window w_info;
2200 int iScrollHeight = 0;
2201
2202 std::unique_ptr<ui_adaptor> ui = std::make_unique<ui_adaptor>();
2203 ui->on_screen_resize( [&]( ui_adaptor & ui ) {
2204 w_info = catacurses::newwin( TERMY, iWidth(), point( iStartX(), 0 ) );
2205 iScrollHeight = TERMY - 2;
2206 ui.position_from_window( w_info );
2207 } );
2208 ui->mark_resize();
2209
2210 ui->on_redraw( [&]( const ui_adaptor & ) {
2211 draw_item_info( w_info, data );
2212 } );
2213
2214 bool exit = false;
2215 do {
2216 const int prev_selected = action_menu.selected;
2217 action_menu.query( false );
2218 if( action_menu.ret >= 0 ) {
2219 cMenu = action_menu.ret; /* Remember: hotkey == retval, see addentry above. */
2220 } else if( action_menu.ret == UILIST_UNBOUND && action_menu.keypress == KEY_RIGHT ) {
2221 // Simulate KEY_RIGHT == '\n' (confirm currently selected entry) for compatibility with old version.
2222 // TODO: ideally this should be done in the uilist, maybe via a callback.
2223 cMenu = action_menu.ret = action_menu.entries[action_menu.selected].retval;
2224 } else if( action_menu.keypress == KEY_PPAGE || action_menu.keypress == KEY_NPAGE ) {
2225 cMenu = action_menu.keypress;
2226 // Prevent the menu from scrolling with this key. TODO: Ideally the menu
2227 // could be instructed to ignore these two keys instead of scrolling.
2228 action_menu.selected = prev_selected;
2229 action_menu.fselected = prev_selected;
2230 action_menu.vshift = 0;
2231 } else {
2232 cMenu = 0;
2233 }
2234
2235 if( action_menu.ret != UILIST_WAIT_INPUT && action_menu.ret != UILIST_UNBOUND ) {
2236 exit = true;
2237 ui = nullptr;
2238 }
2239
2240 switch( cMenu ) {
2241 case 'a':
2242 avatar_action::use_item( u, locThisItem );
2243 break;
2244 case 'E':
2245 avatar_action::eat( u, locThisItem );
2246 break;
2247 case 'W':
2248 u.wear( oThisItem );
2249 break;
2250 case 'w':
2251 wield( locThisItem );
2252 break;
2253 case 't':
2254 avatar_action::plthrow( u, locThisItem );
2255 break;
2256 case 'c':
2257 u.change_side( locThisItem );
2258 break;
2259 case 'T':
2260 u.takeoff( oThisItem );
2261 break;
2262 case 'd':
2263 u.drop( locThisItem, u.pos() );
2264 break;
2265 case 'U':
2266 unload( locThisItem );
2267 break;
2268 case 'r':
2269 reload( locThisItem );
2270 break;
2271 case 'p':
2272 reload( locThisItem, true );
2273 break;
2274 case 'm':
2275 avatar_action::mend( u, locThisItem );
2276 break;
2277 case 'R':
2278 u.read( locThisItem );
2279 break;
2280 case 'D':
2281 u.disassemble( locThisItem, false );
2282 break;
2283 case 'f':
2284 oThisItem.is_favorite = !oThisItem.is_favorite;
2285 break;
2286 case '=':
2287 game_menus::inv::reassign_letter( u, oThisItem );
2288 break;
2289 case KEY_PPAGE:
2290 iScrollPos -= iScrollHeight;
2291 if( ui ) {
2292 ui->invalidate_ui();
2293 }
2294 break;
2295 case KEY_NPAGE:
2296 iScrollPos += iScrollHeight;
2297 if( ui ) {
2298 ui->invalidate_ui();
2299 }
2300 break;
2301 case '+':
2302 if( !bHPR ) {
2303 get_auto_pickup().add_rule( &oThisItem );
2304 add_msg( m_info, _( "'%s' added to character pickup rules." ), oThisItem.tname( 1,
2305 false ) );
2306 }
2307 break;
2308 case '-':
2309 if( bHPR ) {
2310 get_auto_pickup().remove_rule( &oThisItem );
2311 add_msg( m_info, _( "'%s' removed from character pickup rules." ), oThisItem.tname( 1,
2312 false ) );
2313 }
2314 break;
2315 default:
2316 break;
2317 }
2318 } while( !exit );
2319 }
2320 return cMenu;
2321}
hint_rating rate_action_change_side(const item &it) const
Used to determine player feedback on item use for the inventory code.
Definition: character.cpp:3698
bool is_wielding(const item &target) const
Definition: character.cpp:3238
bool change_side(item &it, bool interactive=true)
Swap side on which item is worn; returns false on fail.
Definition: character.cpp:3711
ret_val< bool > can_unwield(const item &it) const
Check player capable of unwielding an item.
Definition: character.cpp:3158
bool is_wearing(const item &itm) const
Returns true if the player is wearing the item.
Definition: character.cpp:3243
hint_rating rate_action_eat(const item &it) const
void remove_rule(const item *it)
bool has_rule(const item *it)
void add_rule(const item *it)
hint_rating rate_action_read(const item &it) const
Definition: avatar.cpp:936
bool read(item_location loc, bool continuous=false)
Handles reading effects and returns true if activity started.
Definition: avatar.cpp:369
bool unload(item_location loc)
Definition: game.cpp:9026
void reload(item_location &loc, bool prompt=false, bool empty=true)
Definition: game.cpp:8854
bool is_favorite
Definition: item.h:2234
std::string info(bool showtext=false) const
Return all the information about the item and its type.
Definition: item.cpp:1103
std::string type_name(unsigned int quantity=1) const
Name of the item type (not the item), with proper plural.
Definition: item.cpp:9672
std::string tname(unsigned int quantity=1, bool with_prefix=true, unsigned int truncate=0) const
Return the (translated) item name.
Definition: item.cpp:4438
char invlet
Definition: item.h:2232
hint_rating rate_action_mend(const item &it) const
Definition: player.cpp:3191
cata::optional< std::list< item >::iterator > wear(int pos, bool interactive=true)
Wear item; returns false on fail.
Definition: player.cpp:2768
hint_rating rate_action_takeoff(const item &it) const
Definition: player.cpp:2818
hint_rating rate_action_reload(const item &it) const
Definition: player.cpp:3129
hint_rating rate_action_wear(const item &it) const
Definition: player.cpp:2533
hint_rating rate_action_disassemble(const item &it)
Definition: player.cpp:3200
ret_val< bool > can_takeoff(const item &it, const std::list< item > *res=nullptr) const
Check player capable of taking off an item.
Definition: player.cpp:2848
hint_rating rate_action_unload(const item &it) const
Definition: player.cpp:3154
bool takeoff(item &it, std::list< item > *res=nullptr)
Takes off an item, returning false on fail.
Definition: player.cpp:2872
hint_rating rate_action_use(const item &it) const
Used to determine player feedback on item use for the inventory code.
Definition: player.cpp:3213
nc_color border_color
Definition: ui.h:328
int keypress
Definition: ui.h:413
bool filtering
Definition: ui.h:354
pos_scalar w_x_setup
Definition: ui.h:337
int fselected
Definition: ui.h:388
int selected
Definition: ui.h:415
bool allow_anykey
Definition: ui.h:360
int vshift
Definition: ui.h:386
std::vector< uilist_entry > entries
Definition: ui.h:323
bool has_item(const item &it) const
Returns true if this visitable instance contains the item.
Definition: visitable.cpp:95
static constexpr int KEY_NPAGE
Definition: input.h:65
static constexpr int KEY_PPAGE
Definition: input.h:66
static constexpr int KEY_RIGHT
Definition: input.h:40
hint_rating
Hint value used in a hack to decide text color.
Definition: item.h:2257
@ iffy
Item should display as red.
@ good
Item should display as green.
@ cant
Item should display as gray.
void reassign_letter(player &p, item &it)
input_event draw_item_info(const int iLeft, const int iWidth, const int iTop, const int iHeight, item_info_data &data)
Definition: output.cpp:793
#define BORDER_COLOR
Definition: output.h:135
const int UILIST_UNBOUND
Definition: ui.h:27
const int UILIST_WAIT_INPUT
Definition: ui.h:26

References _, add_msg(), auto_pickup::player_settings::add_rule(), uilist::addentry(), uilist::allow_anykey, BORDER_COLOR, uilist::border_color, c_light_gray, c_light_green, c_light_red, player::can_takeoff(), Character::can_unwield(), cant, Character::change_side(), player::disassemble(), draw_item_info(), Character::drop(), avatar_action::eat(), uilist::entries, uilist::filtering, uilist::fselected, get_auto_pickup(), good, visitable< T >::has_item(), auto_pickup::player_settings::has_rule(), iffy, item::info(), item::invlet, Character::is_armed(), item::is_favorite, Character::is_wearing(), Character::is_wielding(), KEY_NPAGE, KEY_PPAGE, KEY_RIGHT, uilist::keypress, LEFT_OF_INFO, LEFT_TERMINAL_EDGE, m_info, avatar_action::mend(), catacurses::newwin(), pgettext(), avatar_action::plthrow(), Character::pos(), uilist::query(), Character::rate_action_change_side(), player::rate_action_disassemble(), Character::rate_action_eat(), player::rate_action_mend(), avatar::rate_action_read(), player::rate_action_reload(), player::rate_action_takeoff(), player::rate_action_unload(), player::rate_action_use(), player::rate_action_wear(), avatar::read(), game_menus::inv::reassign_letter(), reload(), auto_pickup::player_settings::remove_rule(), uilist::ret, RIGHT_OF_INFO, RIGHT_TERMINAL_EDGE, uilist::selected, player::takeoff(), TERMX, TERMY, item::tname(), item::type_name(), u, UILIST_UNBOUND, UILIST_WAIT_INPUT, unload(), avatar_action::use_item(), uilist::vshift, uilist::w_x_setup, uilist::w_y_setup, Character::weapon, player::wear(), wield(), and item_info_data::without_getch.

◆ is_core_data_loaded()

bool game::is_core_data_loaded ( ) const

Returns whether the core data is currently loaded.

Definition at line 433 of file game.cpp.

434{
436}
bool is_data_finalized() const
Returns whether the data is finalized and ready to be utilized.
Definition: init.h:167

References DynamicDataLoader::get_instance(), and DynamicDataLoader::is_data_finalized().

◆ is_dangerous_tile()

bool game::is_dangerous_tile ( const tripoint dest_loc) const

Definition at line 9259 of file game.cpp.

9260{
9261 return !( get_dangerous_tile( dest_loc ).empty() );
9262}
std::vector< std::string > get_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:9281

References get_dangerous_tile().

Referenced by walk_move().

◆ is_empty()

bool game::is_empty ( const tripoint p)

Returns true if there is no player, NPC, or monster on the tile and move_cost > 0.

Definition at line 5161 of file game.cpp.

5162{
5163 return ( m.passable( p ) || m.has_flag( "LIQUID", p ) ) &&
5164 critter_at( p ) == nullptr;
5165}

References critter_at(), map::has_flag(), m, and map::passable().

Referenced by grabbed_furn_move(), monmove(), place_player(), and update_stair_monsters().

◆ is_game_over()

bool game::is_game_over ( )
private

Definition at line 2691 of file game.cpp.

2692{
2693 if( uquit == QUIT_WATCH ) {
2694 // deny player movement and dodging
2695 u.moves = 0;
2696 // prevent pain from updating
2697 u.set_pain( 0 );
2698 // prevent dodging
2699 u.dodges_left = 0;
2700 return false;
2701 }
2702 if( uquit == QUIT_DIED ) {
2703 if( u.in_vehicle ) {
2704 m.unboard_vehicle( u.pos() );
2705 }
2706 u.place_corpse();
2707 return true;
2708 }
2709 if( uquit == QUIT_SUICIDE ) {
2710 if( u.in_vehicle ) {
2711 m.unboard_vehicle( u.pos() );
2712 }
2713 return true;
2714 }
2715 if( uquit != QUIT_NO ) {
2716 return true;
2717 }
2718 // is_dead_state() already checks hp_torso && hp_head, no need to for loop it
2719 if( u.is_dead_state() ) {
2721 if( get_option<std::string>( "DEATHCAM" ) == "always" ) {
2722 uquit = QUIT_WATCH;
2723 } else if( get_option<std::string>( "DEATHCAM" ) == "ask" ) {
2724 uquit = query_yn( _( "Watch the last moments of your life…?" ) ) ?
2726 } else if( get_option<std::string>( "DEATHCAM" ) == "never" ) {
2727 uquit = QUIT_DIED;
2728 } else {
2729 // Something funky happened here, just die.
2730 dbg( DL::Error ) << "no deathcam option given to options, defaulting to QUIT_DIED";
2731 uquit = QUIT_DIED;
2732 }
2733 return is_game_over();
2734 }
2735 return false;
2736}
int dodges_left
Definition: character.h:558
void set_pain(int npain) override
Sets new intensity of pain an reacts to it.
Definition: player.cpp:1014
@ Error
Error (default: enabled).
#define dbg(x)
Definition: game.cpp:189
void deactivate()
Definition: messages.cpp:357

References _, dbg, Messages::deactivate(), Character::dodges_left, Error, Character::in_vehicle, player::is_dead_state(), is_game_over(), m, Creature::moves, Character::place_corpse(), Character::pos(), query_yn(), QUIT_DIED, QUIT_NO, QUIT_SUICIDE, QUIT_WATCH, player::set_pain(), u, map::unboard_vehicle(), and uquit.

Referenced by do_turn(), and is_game_over().

◆ is_hostile_nearby()

Creature * game::is_hostile_nearby ( )

Definition at line 3950 of file game.cpp.

3951{
3952 int distance = ( get_option<int>( "SAFEMODEPROXIMITY" ) <= 0 ) ? MAX_VIEW_DISTANCE :
3953 get_option<int>( "SAFEMODEPROXIMITY" );
3954 return is_hostile_within( distance );
3955}
Creature * is_hostile_within(int distance)
Definition: game.cpp:3962

References is_hostile_within(), and MAX_VIEW_DISTANCE.

◆ is_hostile_very_close()

Creature * game::is_hostile_very_close ( )

Definition at line 3957 of file game.cpp.

3958{
3960}
static constexpr int DANGEROUS_PROXIMITY
Definition: game.cpp:191

References DANGEROUS_PROXIMITY, and is_hostile_within().

Referenced by butcher(), and process_voluntary_act_interrupt().

◆ is_hostile_within()

Creature * game::is_hostile_within ( int  distance)
private

Definition at line 3962 of file game.cpp.

3963{
3964 for( auto &critter : u.get_visible_creatures( distance ) ) {
3965 if( u.attitude_to( *critter ) == Creature::A_HOSTILE ) {
3966 return critter;
3967 }
3968 }
3969
3970 return nullptr;
3971}
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
std::vector< Creature * > get_visible_creatures(int range) const
Returns all creatures that this player can see and that are in the given range.
@ A_HOSTILE
Definition: creature.h:169

References Creature::A_HOSTILE, Character::attitude_to(), Character::get_visible_creatures(), and u.

Referenced by is_hostile_nearby(), and is_hostile_very_close().

◆ is_in_sunlight()

bool game::is_in_sunlight ( const tripoint p)

Returns true if p is outdoors and it is sunny.

Definition at line 5167 of file game.cpp.

5168{
5169 return weather::is_in_sunlight( m, p, get_weather().weather_id );
5170}
bool is_in_sunlight(const map &m, const tripoint &p, const weather_type_id &weather)
Definition: weather.cpp:1162

References get_weather, weather::is_in_sunlight(), and m.

Referenced by process_artifact().

◆ is_in_viewport()

bool game::is_in_viewport ( const tripoint p,
int  margin = 0 
) const

Definition at line 3596 of file game.cpp.

3597{
3598 const tripoint diff( u.pos() + u.view_offset - p );
3599
3600 return ( std::abs( diff.x ) <= getmaxx( w_terrain ) / 2 - margin ) &&
3601 ( std::abs( diff.y ) <= getmaxy( w_terrain ) / 2 - margin );
3602}

References catacurses::getmaxx(), catacurses::getmaxy(), Character::pos(), u, player::view_offset, w_terrain, tripoint::x, and tripoint::y.

◆ is_sheltered()

bool game::is_sheltered ( const tripoint p)

Returns true if p is indoors, underground, or in a car.

Definition at line 5172 of file game.cpp.

5173{
5174 return weather::is_sheltered( m, p );
5175}
bool is_sheltered(const map &m, const tripoint &p)
Definition: weather.cpp:1153

References weather::is_sheltered(), and m.

◆ is_zones_manager_open()

bool game::is_zones_manager_open ( ) const

Definition at line 6315 of file game.cpp.

6316{
6317 return zones_manager_open;
6318}
bool zones_manager_open
Is Zone manager open or not - changes graphics of some zone tiles.
Definition: game.h:1101

References zones_manager_open.

◆ item_action_menu()

void game::item_action_menu ( )
private

Definition at line 231 of file item_action.cpp.

232{
233 const auto &gen = item_action_generator::generator();
234 const action_map &item_actions = gen.get_item_action_map();
235
236 // HACK: A bit of a hack for now. If more pseudos get implemented, this should be un-hacked
237 std::vector<item *> pseudos;
238 item toolset( "toolset", calendar::turn );
239 if( u.has_active_bionic( bio_tools ) ) {
240 pseudos.push_back( &toolset );
241 }
242 item bio_claws_item( static_cast<std::string>( bio_claws_weapon ), calendar::turn );
243 if( u.has_active_bionic( bio_claws ) ) {
244 pseudos.push_back( &bio_claws_item );
245 }
246
247 item_action_map iactions = gen.map_actions_to_items( u, pseudos );
248 if( iactions.empty() ) {
249 popup( _( "You don't have any items with registered uses" ) );
250 }
251
252 uilist kmenu;
253 kmenu.text = _( "Execute which action?" );
254 kmenu.input_category = "ITEM_ACTIONS";
255 input_context ctxt( "ITEM_ACTIONS" );
256 for( const auto &id : item_actions ) {
257 ctxt.register_action( id.first, id.second.name );
258 kmenu.additional_actions.emplace_back( id.first, id.second.name );
259 }
260 actmenu_cb callback( item_actions );
261 kmenu.callback = &callback;
262 int num = 0;
263
264 const auto assigned_action = [&iactions]( const item_action_id & action ) {
265 return iactions.find( action ) != iactions.end();
266 };
267
268 std::vector<std::tuple<item_action_id, std::string, std::string>> menu_items;
269 // Sorts menu items by action.
270 using Iter = decltype( menu_items )::iterator;
271 const auto sort_menu = []( Iter from, Iter to ) {
272 std::sort( from, to, []( const std::tuple<item_action_id, std::string, std::string> &lhs,
273 const std::tuple<item_action_id, std::string, std::string> &rhs ) {
274 return std::get<1>( lhs ).compare( std::get<1>( rhs ) ) < 0;
275 } );
276 };
277 // Add mapped actions to the menu vector.
278 std::transform( iactions.begin(), iactions.end(), std::back_inserter( menu_items ),
279 []( const std::pair<item_action_id, item *> &elem ) {
280 std::string ss = elem.second->display_name();
281 if( elem.second->ammo_required() ) {
282 ss += string_format( " (%d/%d)", elem.second->ammo_required(), elem.second->ammo_remaining() );
283 }
284
285 const auto method = elem.second->get_use( elem.first );
286 if( method ) {
287 return std::make_tuple( method->get_type(), method->get_name(), ss );
288 } else {
289 return std::make_tuple( errstring, std::string( "NO USE FUNCTION" ), ss );
290 }
291 } );
292 // Sort mapped actions.
293 sort_menu( menu_items.begin(), menu_items.end() );
294 // Add unmapped but binded actions to the menu vector.
295 for( const auto &elem : item_actions ) {
296 if( key_bound_to( ctxt, elem.first ) != '\0' && !assigned_action( elem.first ) ) {
297 menu_items.emplace_back( elem.first, gen.get_action_name( elem.first ), "-" );
298 }
299 }
300 // Sort unmapped actions.
301 auto iter = menu_items.begin();
302 std::advance( iter, iactions.size() );
303 sort_menu( iter, menu_items.end() );
304 // Determine max lengths, to print the menu nicely.
305 std::pair<int, int> max_len;
306 for( const auto &elem : menu_items ) {
307 max_len.first = std::max( max_len.first, utf8_width( std::get<1>( elem ), true ) );
308 max_len.second = std::max( max_len.second, utf8_width( std::get<2>( elem ), true ) );
309 }
310 // Fill the menu.
311 for( const auto &elem : menu_items ) {
312 std::string ss;
313 ss += std::get<1>( elem );
314 ss += std::string( max_len.first - utf8_width( std::get<1>( elem ), true ), ' ' );
315 ss += std::string( 4, ' ' );
316
317 ss += std::get<2>( elem );
318 ss += std::string( max_len.second - utf8_width( std::get<2>( elem ), true ), ' ' );
319
320 const char bind = key_bound_to( ctxt, std::get<0>( elem ) );
321 const bool enabled = assigned_action( std::get<0>( elem ) );
322
323 kmenu.addentry( num, enabled, bind, ss );
324 num++;
325 }
326
327 kmenu.query();
328 if( kmenu.ret < 0 || kmenu.ret >= static_cast<int>( iactions.size() ) ) {
329 return;
330 }
331
332 const item_action_id action = std::get<0>( menu_items[kmenu.ret] );
333 item *it = iactions[action];
334
335 u.invoke_item( it, action );
336
337 u.inv.restack( u );
338 u.inv.unsort();
339}
inventory inv
Definition: character.h:1527
bool invoke_item(item *, const tripoint &pt) override
Asks how to use the item (if it has more than one use_method) and uses it.
Definition: avatar.cpp:1242
void restack(player &p)
Definition: inventory.cpp:398
void unsort()
Definition: inventory.cpp:226
static item_action_generator & generator()
Definition: item_action.h:32
std::string input_category
Definition: ui.h:325
std::vector< std::pair< std::string, translation > > additional_actions
Definition: ui.h:326
static char key_bound_to(const input_context &ctxt, const item_action_id &act)
Definition: item_action.cpp:47
static const bionic_id bio_claws("bio_claws")
static const bionic_id bio_tools("bio_tools")
static const bionic_id bio_claws_weapon("bio_claws_weapon")
std::string item_action_id
Definition: item_action.h:16
std::map< item_action_id, item_action > action_map
Definition: item_action.h:18
std::map< item_action_id, item * > item_action_map
Definition: item_action.h:17

References _, action, uilist::additional_actions, bio_claws, bio_claws_weapon, bio_tools, uilist::callback, item_action_generator::generator(), Character::has_active_bionic(), uilist::input_category, num, popup(), input_context::register_action(), second, uilist::text, iexamine::transform(), calendar::turn, and u.

Referenced by handle_action().

◆ knockback() [1/2]

void game::knockback ( const tripoint s,
const tripoint t,
int  force,
int  stun,
int  dam_mult 
)

Definition at line 4586 of file game.cpp.

4587{
4588 std::vector<tripoint> traj;
4589 traj.clear();
4590 traj = line_to( s, t, 0, 0 );
4591 traj.insert( traj.begin(), s ); // how annoying, line_to() doesn't include the originating point!
4592 traj = continue_line( traj, force );
4593 traj.insert( traj.begin(), t ); // how annoying, continue_line() doesn't either!
4594
4595 knockback( traj, stun, dam_mult );
4596}
std::vector< coords::coord_point< Point, Origin, Scale > > line_to(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:548
std::vector< tripoint > continue_line(const std::vector< tripoint > &line, const int distance)
Definition: line.cpp:408

References continue_line(), knockback(), and line_to().

Referenced by forced_door_closing(), and knockback().

◆ knockback() [2/2]

void game::knockback ( std::vector< tripoint > &  traj,
int  stun,
int  dam_mult 
)

Definition at line 4602 of file game.cpp.

4603{
4604 // TODO: make the force parameter actually do something.
4605 // the header file says higher force causes more damage.
4606 // perhaps that is what it should do?
4607
4608 // TODO: refactor this so it's not copy/pasted 3 times
4609 tripoint tp = traj.front();
4610 if( !critter_at( tp ) ) {
4611 debugmsg( _( "Nothing at (%d,%d,%d) to knockback!" ), tp.x, tp.y, tp.z );
4612 return;
4613 }
4614 std::size_t force_remaining = traj.size();
4615 if( monster *const targ = critter_at<monster>( tp, true ) ) {
4616 if( stun > 0 ) {
4617 targ->add_effect( effect_stunned, 1_turns * stun );
4618 add_msg( _( "%s was stunned!" ), targ->name() );
4619 }
4620 for( size_t i = 1; i < traj.size(); i++ ) {
4621 if( m.impassable( traj[i].xy() ) || m.obstructed_by_vehicle_rotation( tp, traj[i] ) ) {
4622 targ->setpos( traj[i - 1] );
4623 force_remaining = traj.size() - i;
4624 if( stun != 0 ) {
4625 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4626 add_msg( _( "%s was stunned!" ), targ->name() );
4627 add_msg( _( "%s slammed into an obstacle!" ), targ->name() );
4628 targ->apply_damage( nullptr, bodypart_id( "torso" ), dam_mult * force_remaining );
4629 targ->check_dead_state();
4630 }
4631 m.bash( traj[i], 2 * dam_mult * force_remaining );
4632 break;
4633 } else if( critter_at( traj[i] ) ) {
4634 targ->setpos( traj[i - 1] );
4635 force_remaining = traj.size() - i;
4636 if( stun != 0 ) {
4637 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4638 add_msg( _( "%s was stunned!" ), targ->name() );
4639 }
4640 traj.erase( traj.begin(), traj.begin() + i );
4641 if( critter_at<monster>( traj.front() ) ) {
4642 add_msg( _( "%s collided with something else and sent it flying!" ),
4643 targ->name() );
4644 } else if( npc *const guy = critter_at<npc>( traj.front() ) ) {
4645 if( guy->male ) {
4646 add_msg( _( "%s collided with someone else and sent him flying!" ),
4647 targ->name() );
4648 } else {
4649 add_msg( _( "%s collided with someone else and sent her flying!" ),
4650 targ->name() );
4651 }
4652 } else if( u.pos() == traj.front() ) {
4653 add_msg( m_bad, _( "%s collided with you and sent you flying!" ), targ->name() );
4654 }
4655 knockback( traj, stun, dam_mult );
4656 break;
4657 }
4658 targ->setpos( traj[i] );
4659 if( m.has_flag( "LIQUID", targ->pos() ) && !targ->can_drown() && !targ->is_dead() ) {
4660 targ->die( nullptr );
4661 if( u.sees( *targ ) ) {
4662 add_msg( _( "The %s drowns!" ), targ->name() );
4663 }
4664 }
4665 if( !m.has_flag( "LIQUID", targ->pos() ) && targ->has_flag( MF_AQUATIC ) &&
4666 !targ->is_dead() ) {
4667 targ->die( nullptr );
4668 if( u.sees( *targ ) ) {
4669 add_msg( _( "The %s flops around and dies!" ), targ->name() );
4670 }
4671 }
4672 tp = traj[i];
4673 }
4674 } else if( npc *const targ = critter_at<npc>( tp ) ) {
4675 if( stun > 0 ) {
4676 targ->add_effect( effect_stunned, 1_turns * stun );
4677 add_msg( _( "%s was stunned!" ), targ->name );
4678 }
4679 for( size_t i = 1; i < traj.size(); i++ ) {
4680 if( m.impassable( traj[i].xy() ) ||
4681 m.obstructed_by_vehicle_rotation( tp, traj[i] ) ) { // oops, we hit a wall!
4682 targ->setpos( traj[i - 1] );
4683 force_remaining = traj.size() - i;
4684 if( stun != 0 ) {
4685 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4686 if( targ->has_effect( effect_stunned ) ) {
4687 add_msg( _( "%s was stunned!" ), targ->name );
4688 }
4689
4690 std::array<bodypart_id, 8> bps = {{
4691 bodypart_id( "head" ),
4692 bodypart_id( "arm_l" ), bodypart_id( "arm_r" ),
4693 bodypart_id( "hand_l" ), bodypart_id( "hand_r" ),
4694 bodypart_id( "torso" ),
4695 bodypart_id( "leg_l" ), bodypart_id( "leg_r" )
4696 }
4697 };
4698 for( const bodypart_id &bp : bps ) {
4699 if( one_in( 2 ) ) {
4700 targ->deal_damage( nullptr, bp, damage_instance( DT_BASH, force_remaining * dam_mult ) );
4701 }
4702 }
4703 targ->check_dead_state();
4704 }
4705 m.bash( traj[i], 2 * dam_mult * force_remaining );
4706 break;
4707 } else if( critter_at( traj[i] ) ) {
4708 targ->setpos( traj[i - 1] );
4709 force_remaining = traj.size() - i;
4710 if( stun != 0 ) {
4711 add_msg( _( "%s was stunned!" ), targ->name );
4712 targ->add_effect( effect_stunned, 1_turns * force_remaining );
4713 }
4714 traj.erase( traj.begin(), traj.begin() + i );
4715 const tripoint &traj_front = traj.front();
4716 if( critter_at<monster>( traj_front ) ) {
4717 add_msg( _( "%s collided with something else and sent it flying!" ),
4718 targ->name );
4719 } else if( npc *const guy = critter_at<npc>( traj_front ) ) {
4720 if( guy->male ) {
4721 add_msg( _( "%s collided with someone else and sent him flying!" ),
4722 targ->name );
4723 } else {
4724 add_msg( _( "%s collided with someone else and sent her flying!" ),
4725 targ->name );
4726 }
4727 } else if( u.posx() == traj_front.x && u.posy() == traj_front.y &&
4729 ( u.footwear_factor() == .5 && one_in( 2 ) ) ) ) ) {
4730 add_msg( _( "%s collided with you, and barely dislodges your tentacles!" ), targ->name );
4731 } else if( u.posx() == traj_front.x && u.posy() == traj_front.y ) {
4732 add_msg( m_bad, _( "%s collided with you and sent you flying!" ), targ->name );
4733 }
4734 knockback( traj, stun, dam_mult );
4735 break;
4736 }
4737 targ->setpos( traj[i] );
4738 tp = traj[i];
4739 }
4740 } else if( u.pos() == tp ) {
4741 if( stun > 0 ) {
4742 u.add_effect( effect_stunned, 1_turns * stun );
4743 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4744 "You were stunned for %d turns!",
4745 stun ),
4746 stun );
4747 }
4748 for( size_t i = 1; i < traj.size(); i++ ) {
4749 if( m.impassable( traj[i] ) ||
4750 m.obstructed_by_vehicle_rotation( tp, traj[i] ) ) { // oops, we hit a wall!
4751 u.setpos( traj[i - 1] );
4752 force_remaining = traj.size() - i;
4753 if( stun != 0 ) {
4754 if( u.has_effect( effect_stunned ) ) {
4755 add_msg( m_bad, vgettext( "You were stunned AGAIN for %d turn!",
4756 "You were stunned AGAIN for %d turns!",
4757 force_remaining ),
4758 force_remaining );
4759 } else {
4760 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4761 "You were stunned for %d turns!",
4762 force_remaining ),
4763 force_remaining );
4764 }
4765 u.add_effect( effect_stunned, 1_turns * force_remaining );
4766 std::array<bodypart_id, 8> bps = {{
4767 bodypart_id( "head" ),
4768 bodypart_id( "arm_l" ), bodypart_id( "arm_r" ),
4769 bodypart_id( "hand_l" ), bodypart_id( "hand_r" ),
4770 bodypart_id( "torso" ),
4771 bodypart_id( "leg_l" ), bodypart_id( "leg_r" )
4772 }
4773 };
4774 for( const bodypart_id &bp : bps ) {
4775 if( one_in( 2 ) ) {
4776 u.deal_damage( nullptr, bp, damage_instance( DT_BASH, force_remaining * dam_mult ) );
4777 }
4778 }
4780 }
4781 m.bash( traj[i], 2 * dam_mult * force_remaining );
4782 break;
4783 } else if( critter_at( traj[i] ) ) {
4784 u.setpos( traj[i - 1] );
4785 force_remaining = traj.size() - i;
4786 if( stun != 0 ) {
4787 if( u.has_effect( effect_stunned ) ) {
4788 add_msg( m_bad, vgettext( "You were stunned AGAIN for %d turn!",
4789 "You were stunned AGAIN for %d turns!",
4790 force_remaining ),
4791 force_remaining );
4792 } else {
4793 add_msg( m_bad, vgettext( "You were stunned for %d turn!",
4794 "You were stunned for %d turns!",
4795 force_remaining ),
4796 force_remaining );
4797 }
4798 u.add_effect( effect_stunned, 1_turns * force_remaining );
4799 }
4800 traj.erase( traj.begin(), traj.begin() + i );
4801 if( critter_at<monster>( traj.front() ) ) {
4802 add_msg( _( "You collided with something and sent it flying!" ) );
4803 } else if( npc *const guy = critter_at<npc>( traj.front() ) ) {
4804 if( guy->male ) {
4805 add_msg( _( "You collided with someone and sent him flying!" ) );
4806 } else {
4807 add_msg( _( "You collided with someone and sent her flying!" ) );
4808 }
4809 }
4810 knockback( traj, stun, dam_mult );
4811 break;
4812 }
4813 if( m.has_flag( "LIQUID", u.pos() ) && force_remaining == 0 ) {
4814 avatar_action::swim( m, u, u.pos() );
4815 } else {
4816 u.setpos( traj[i] );
4817 }
4818
4819 tp = traj[i];
4820 }
4821 }
4822}
double footwear_factor() const
Returns 1 if the player is wearing something on both feet, .5 if on one, and 0 if on neither.
Definition: character.cpp:8949
dealt_damage_instance deal_damage(Creature *source, bodypart_id bp, const damage_instance &d) override
Calls Creature::deal_damage and handles damaged effects (waking up, etc.)
Definition: character.cpp:8473
void add_effect(const effect &eff, bool force=false, bool deferred=false)
Definition: creature.cpp:980
@ DT_BASH
Definition: damage.h:24
static const trait_id trait_LEG_TENT_BRACE("LEG_TENT_BRACE")
static const efftype_id effect_stunned("stunned")
@ MF_AQUATIC
Definition: mtype.h:89
void swim(map &m, avatar &you, const tripoint &p)
Handles swimming by the player.
const char * vgettext(const char *msgid, const char *msgid_plural, size_t n)

References _, Creature::add_effect(), add_msg(), map::bash(), Creature::check_dead_state(), critter_at(), Character::deal_damage(), debugmsg, DT_BASH, effect_stunned, Character::footwear_factor(), Creature::has_effect(), map::has_flag(), Character::has_trait(), map::impassable(), knockback(), m, m_bad, MF_AQUATIC, map::obstructed_by_vehicle_rotation(), one_in(), Character::pos(), Character::posx(), Character::posy(), Character::sees(), Character::setpos(), avatar_action::swim(), trait_LEG_TENT_BRACE, u, vgettext(), tripoint::x, tripoint::y, and tripoint::z.

◆ light_level()

unsigned char game::light_level ( int  zlev) const

Returns coarse number-of-squares of visibility at the current light level.

Used by monster and NPC AI.

Definition at line 3929 of file game.cpp.

3930{
3931 const float light = natural_light_level( zlev );
3932 return LIGHT_RANGE( light );
3933}
float natural_light_level(int zlev) const
Definition: game.cpp:3869
#define LIGHT_RANGE(b)
Definition: lightmap.h:41

References light, LIGHT_RANGE, and natural_light_level().

Referenced by calc_driving_offset(), and update_overmap_seen().

◆ list_active_characters()

std::vector< std::string > game::list_active_characters ( )

Returns a list of currently active character saves.

Definition at line 3136 of file game.cpp.

3137{
3138 std::vector<std::string> saves;
3139 for( auto &worldsave : world_generator->active_world->world_saves ) {
3140 saves.push_back( worldsave.player_name() );
3141 }
3142 return saves;
3143}

References world_generator.

Referenced by cleanup_at_end().

◆ list_items()

game::vmenu_ret game::list_items ( const std::vector< map_item_stack > &  item_list)
private

Definition at line 7549 of file game.cpp.

7550{
7551 std::vector<map_item_stack> ground_items = item_list;
7552 int iInfoHeight = 0;
7553 int iMaxRows = 0;
7554 int width = 0;
7555 int max_name_width = 0;
7556
7557 //find max length of item name and resize window width
7558 for( const map_item_stack &cur_item : ground_items ) {
7559 const int item_len = utf8_width( remove_color_tags( cur_item.example->display_name() ) ) + 15;
7560 if( item_len > max_name_width ) {
7561 max_name_width = item_len;
7562 }
7563 }
7564
7565 tripoint active_pos;
7566 map_item_stack *activeItem = nullptr;
7567
7568 catacurses::window w_items;
7569 catacurses::window w_items_border;
7570 catacurses::window w_item_info;
7571
7572 ui_adaptor ui;
7573 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
7574 iInfoHeight = std::min( 25, TERMY / 2 );
7575 iMaxRows = TERMY - iInfoHeight - 2;
7576
7577 width = clamp( max_name_width, 45, TERMX / 3 );
7578
7579 const int offsetX = TERMX - width;
7580
7581 w_items = catacurses::newwin( TERMY - 2 - iInfoHeight,
7582 width - 2, point( offsetX + 1, 1 ) );
7583 w_items_border = catacurses::newwin( TERMY - iInfoHeight,
7584 width, point( offsetX, 0 ) );
7585 w_item_info = catacurses::newwin( iInfoHeight, width,
7586 point( offsetX, TERMY - iInfoHeight ) );
7587
7588 if( activeItem ) {
7589 centerlistview( active_pos, width );
7590 }
7591
7592 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
7593 } );
7594 ui.mark_resize();
7595
7596 // use previously selected sorting method
7597 bool sort_radius = uistate.list_item_sort != 2;
7598 bool addcategory = !sort_radius;
7599
7600 // reload filter/priority settings on the first invocation, if they were active
7601 if( !uistate.list_item_init ) {
7604 }
7607 }
7610 }
7611 uistate.list_item_init = true;
7612 }
7613
7614 //this stores only those items that match our filter
7615 std::vector<map_item_stack> filtered_items =
7616 !sFilter.empty() ? filter_item_stacks( ground_items, sFilter ) : ground_items;
7617 int highPEnd = list_filter_high_priority( filtered_items, list_item_upvote );
7618 int lowPStart = list_filter_low_priority( filtered_items, highPEnd, list_item_downvote );
7619 int iItemNum = ground_items.size();
7620
7621 const tripoint stored_view_offset = u.view_offset;
7622
7624
7625 int iActive = 0; // Item index that we're looking at
7626 bool refilter = true;
7627 int page_num = 0;
7628 int iCatSortNum = 0;
7629 int iScrollPos = 0;
7630 std::map<int, std::string> mSortCategory;
7631
7632 std::string action;
7633 input_context ctxt( "LIST_ITEMS" );
7634 ctxt.register_action( "UP", to_translation( "Move cursor up" ) );
7635 ctxt.register_action( "DOWN", to_translation( "Move cursor down" ) );
7636 ctxt.register_action( "LEFT", to_translation( "Previous item" ) );
7637 ctxt.register_action( "RIGHT", to_translation( "Next item" ) );
7638 ctxt.register_action( "PAGE_DOWN" );
7639 ctxt.register_action( "PAGE_UP" );
7640 ctxt.register_action( "NEXT_TAB" );
7641 ctxt.register_action( "PREV_TAB" );
7642 ctxt.register_action( "HELP_KEYBINDINGS" );
7643 ctxt.register_action( "QUIT" );
7644 ctxt.register_action( "FILTER" );
7645 ctxt.register_action( "RESET_FILTER" );
7646 ctxt.register_action( "EXAMINE" );
7647 ctxt.register_action( "COMPARE" );
7648 ctxt.register_action( "PRIORITY_INCREASE" );
7649 ctxt.register_action( "PRIORITY_DECREASE" );
7650 ctxt.register_action( "SORT" );
7651 ctxt.register_action( "TRAVEL_TO" );
7652
7654
7655 ui.on_redraw( [&]( const ui_adaptor & ) {
7656 reset_item_list_state( w_items_border, iInfoHeight, sort_radius );
7657
7658 if( ground_items.empty() ) {
7659 wnoutrefresh( w_items_border );
7660 mvwprintz( w_items, point( 2, 10 ), c_white, _( "You don't see any items around you!" ) );
7661 } else {
7662 int iStartPos = 0;
7663 werase( w_items );
7664 calcStartPos( iStartPos, iActive, iMaxRows, iItemNum );
7665 int iNum = 0;
7666 bool high = false;
7667 bool low = false;
7668 int index = 0;
7669 int iCatSortOffset = 0;
7670
7671 for( int i = 0; i < iStartPos; i++ ) {
7672 if( !mSortCategory[i].empty() ) {
7673 iNum++;
7674 }
7675 }
7676 for( auto iter = filtered_items.begin(); iter != filtered_items.end(); ++index ) {
7677 if( highPEnd > 0 && index < highPEnd + iCatSortOffset ) {
7678 high = true;
7679 low = false;
7680 } else if( index >= lowPStart + iCatSortOffset ) {
7681 high = false;
7682 low = true;
7683 } else {
7684 high = false;
7685 low = false;
7686 }
7687
7688 if( iNum >= iStartPos && iNum < iStartPos + ( iMaxRows > iItemNum ? iItemNum : iMaxRows ) ) {
7689 int iThisPage = 0;
7690 if( !mSortCategory[iNum].empty() ) {
7691 iCatSortOffset++;
7692 mvwprintz( w_items, point( 1, iNum - iStartPos ), c_magenta, mSortCategory[iNum] );
7693 } else {
7694 if( iNum == iActive ) {
7695 iThisPage = page_num;
7696 }
7697 std::string sText;
7698 if( iter->vIG.size() > 1 ) {
7699 sText += string_format( "[%d/%d] (%d) ", iThisPage + 1, iter->vIG.size(), iter->totalcount );
7700 }
7701 sText += iter->example->tname();
7702 if( iter->vIG[iThisPage].count > 1 ) {
7703 sText += string_format( "[%d]", iter->vIG[iThisPage].count );
7704 }
7705
7706 nc_color col = c_light_green;
7707 if( iNum != iActive ) {
7708 if( high ) {
7709 col = c_yellow;
7710 } else if( low ) {
7711 col = c_red;
7712 } else {
7713 col = iter->example->color_in_inventory();
7714 }
7715 }
7716 trim_and_print( w_items, point( 1, iNum - iStartPos ), width - 9, col, sText );
7717 const int numw = iItemNum > 9 ? 2 : 1;
7718 const int x = iter->vIG[iThisPage].pos.x;
7719 const int y = iter->vIG[iThisPage].pos.y;
7720 mvwprintz( w_items, point( width - 6 - numw, iNum - iStartPos ),
7721 iNum == iActive ? c_light_green : c_light_gray,
7722 "%*d %s", numw, rl_dist( point_zero, point( x, y ) ),
7724 ++iter;
7725 }
7726 } else {
7727 ++iter;
7728 }
7729 iNum++;
7730 }
7731 iNum = 0;
7732 for( int i = 0; i < iActive; i++ ) {
7733 if( !mSortCategory[i].empty() ) {
7734 iNum++;
7735 }
7736 }
7737 mvwprintz( w_items_border, point( ( width - 9 ) / 2 + ( iItemNum > 9 ? 0 : 1 ), 0 ),
7738 c_light_green, " %*d", iItemNum > 9 ? 2 : 1, iItemNum > 0 ? iActive - iNum + 1 : 0 );
7739 wprintz( w_items_border, c_white, " / %*d ", iItemNum > 9 ? 2 : 1, iItemNum - iCatSortNum );
7740 werase( w_item_info );
7741
7742 if( iItemNum > 0 && activeItem ) {
7743 std::vector<iteminfo> vThisItem;
7744 std::vector<iteminfo> vDummy;
7745 activeItem->example->info( true, vThisItem );
7746
7747 item_info_data dummy( "", "", vThisItem, vDummy, iScrollPos );
7748 dummy.without_getch = true;
7749 dummy.without_border = true;
7750
7751 draw_item_info( w_item_info, dummy );
7752 }
7753 draw_scrollbar( w_items_border, iActive, iMaxRows, iItemNum, point_south );
7754 wnoutrefresh( w_items_border );
7755 }
7756
7757 const bool bDrawLeft = ground_items.empty() || filtered_items.empty() || !activeItem || filter_type;
7758 draw_custom_border( w_item_info, bDrawLeft, true, true, true, LINE_XXXO, LINE_XOXX, true, true );
7759
7760 if( iItemNum > 0 && activeItem ) {
7761 // print info window title: < item name >
7762 mvwprintw( w_item_info, point( 2, 0 ), "< " );
7763 trim_and_print( w_item_info, point( 4, 0 ), width - 8, activeItem->example->color_in_inventory(),
7764 activeItem->example->display_name() );
7765 wprintw( w_item_info, " >" );
7766 }
7767
7768 wnoutrefresh( w_items );
7769 wnoutrefresh( w_item_info );
7770
7771 if( filter_type ) {
7772 draw_item_filter_rules( w_item_info, 0, iInfoHeight - 1, filter_type.value() );
7773 }
7774 } );
7775
7776 cata::optional<tripoint> trail_start;
7777 cata::optional<tripoint> trail_end;
7778 bool trail_end_x = false;
7779 shared_ptr_fast<draw_callback_t> trail_cb = create_trail_callback( trail_start, trail_end,
7780 trail_end_x );
7781 add_draw_callback( trail_cb );
7782
7783 do {
7784 if( action == "COMPARE" && activeItem ) {
7785 game_menus::inv::compare( u, active_pos );
7786 } else if( action == "FILTER" ) {
7787 filter_type = item_filter_type::FILTER;
7788 ui.invalidate_ui();
7790 .title( _( "Filter:" ) )
7791 .width( 55 )
7792 .description( _( "UP: history, CTRL-U: clear line, ESC: abort, ENTER: save" ) )
7793 .identifier( "item_filter" )
7794 .max_length( 256 )
7795 .edit( sFilter );
7796 refilter = true;
7797 addcategory = !sort_radius;
7799 filter_type = cata::nullopt;
7800 } else if( action == "RESET_FILTER" ) {
7801 sFilter.clear();
7802 filtered_items = ground_items;
7803 refilter = true;
7805 addcategory = !sort_radius;
7806 } else if( action == "EXAMINE" && !filtered_items.empty() && activeItem ) {
7807 std::vector<iteminfo> vThisItem;
7808 std::vector<iteminfo> vDummy;
7809 activeItem->example->info( true, vThisItem );
7810
7811 item_info_data info_data( activeItem->example->tname(), activeItem->example->type_name(), vThisItem,
7812 vDummy );
7813 info_data.handle_scrolling = true;
7814
7816 return catacurses::newwin( TERMY, width - 5, point_zero );
7817 }, info_data );
7818 } else if( action == "PRIORITY_INCREASE" ) {
7819 filter_type = item_filter_type::HIGH_PRIORITY;
7820 ui.invalidate_ui();
7822 .title( _( "High Priority:" ) )
7823 .width( 55 )
7825 .description( _( "UP: history, CTRL-U clear line, ESC: abort, ENTER: save" ) )
7826 .identifier( "list_item_priority" )
7827 .max_length( 256 )
7828 .query_string();
7829 refilter = true;
7830 addcategory = !sort_radius;
7832 filter_type = cata::nullopt;
7833 } else if( action == "PRIORITY_DECREASE" ) {
7834 filter_type = item_filter_type::LOW_PRIORITY;
7835 ui.invalidate_ui();
7837 .title( _( "Low Priority:" ) )
7838 .width( 55 )
7840 .description( _( "UP: history, CTRL-U clear line, ESC: abort, ENTER: save" ) )
7841 .identifier( "list_item_downvote" )
7842 .max_length( 256 )
7843 .query_string();
7844 refilter = true;
7845 addcategory = !sort_radius;
7847 filter_type = cata::nullopt;
7848 } else if( action == "SORT" ) {
7849 if( sort_radius ) {
7850 sort_radius = false;
7851 addcategory = true;
7852 uistate.list_item_sort = 2; // list is sorted by category
7853 } else {
7854 sort_radius = true;
7855 uistate.list_item_sort = 1; // list is sorted by distance
7856 }
7857 highPEnd = -1;
7858 lowPStart = -1;
7859 iCatSortNum = 0;
7860
7861 mSortCategory.clear();
7862 refilter = true;
7863 } else if( action == "TRAVEL_TO" && activeItem ) {
7864 if( !u.sees( u.pos() + active_pos ) ) {
7865 add_msg( _( "You can't see that destination." ) );
7866 }
7867 auto route = m.route( u.pos(), u.pos() + active_pos, u.get_pathfinding_settings(),
7868 u.get_path_avoid() );
7869 if( route.size() > 1 ) {
7870 route.pop_back();
7871 u.set_destination( route );
7872 break;
7873 } else {
7874 add_msg( m_info, _( "You can't travel there." ) );
7875 }
7876 }
7877 if( uistate.list_item_sort == 1 ) {
7878 ground_items = item_list;
7879 } else if( uistate.list_item_sort == 2 ) {
7880 std::sort( ground_items.begin(), ground_items.end(), map_item_stack::map_item_stack_sort );
7881 }
7882
7883 if( refilter ) {
7884 refilter = false;
7885 filtered_items = filter_item_stacks( ground_items, sFilter );
7886 highPEnd = list_filter_high_priority( filtered_items, list_item_upvote );
7887 lowPStart = list_filter_low_priority( filtered_items, highPEnd, list_item_downvote );
7888 iActive = 0;
7889 page_num = 0;
7890 iItemNum = filtered_items.size();
7891 }
7892
7893 if( addcategory ) {
7894 addcategory = false;
7895 iCatSortNum = 0;
7896 mSortCategory.clear();
7897 if( highPEnd > 0 ) {
7898 mSortCategory[0] = _( "HIGH PRIORITY" );
7899 iCatSortNum++;
7900 }
7901 std::string last_cat_name;
7902 for( int i = std::max( 0, highPEnd );
7903 i < std::min( lowPStart, static_cast<int>( filtered_items.size() ) ); i++ ) {
7904 const std::string &cat_name = filtered_items[i].example->get_category().name();
7905 if( cat_name != last_cat_name ) {
7906 mSortCategory[i + iCatSortNum++] = cat_name;
7907 last_cat_name = cat_name;
7908 }
7909 }
7910 if( lowPStart < static_cast<int>( filtered_items.size() ) ) {
7911 mSortCategory[lowPStart + iCatSortNum++] = _( "LOW PRIORITY" );
7912 }
7913 if( !mSortCategory[0].empty() ) {
7914 iActive++;
7915 }
7916 iItemNum = static_cast<int>( filtered_items.size() ) + iCatSortNum;
7917 }
7918
7919 if( action == "UP" ) {
7920 do {
7921 iActive--;
7922
7923 } while( !mSortCategory[iActive].empty() );
7924 iScrollPos = 0;
7925 page_num = 0;
7926 if( iActive < 0 ) {
7927 iActive = iItemNum - 1;
7928 }
7929 } else if( action == "DOWN" ) {
7930 do {
7931 iActive++;
7932
7933 } while( !mSortCategory[iActive].empty() );
7934 iScrollPos = 0;
7935 page_num = 0;
7936 if( iActive >= iItemNum ) {
7937 iActive = mSortCategory[0].empty() ? 0 : 1;
7938 }
7939 } else if( action == "RIGHT" ) {
7940 if( !filtered_items.empty() && activeItem ) {
7941 if( ++page_num >= static_cast<int>( activeItem->vIG.size() ) ) {
7942 page_num = activeItem->vIG.size() - 1;
7943 }
7944 }
7945 } else if( action == "LEFT" ) {
7946 page_num = std::max( 0, page_num - 1 );
7947 } else if( action == "PAGE_UP" ) {
7948 iScrollPos--;
7949 } else if( action == "PAGE_DOWN" ) {
7950 iScrollPos++;
7951 } else if( action == "NEXT_TAB" || action == "PREV_TAB" ) {
7952 u.view_offset = stored_view_offset;
7954 }
7955
7956 active_pos = tripoint_zero;
7957 activeItem = nullptr;
7958
7959 if( mSortCategory[iActive].empty() ) {
7960 auto iter = filtered_items.begin();
7961 for( int iNum = 0; iter != filtered_items.end() && iNum < iActive; iNum++ ) {
7962 if( mSortCategory[iNum].empty() ) {
7963 ++iter;
7964 }
7965 }
7966 if( iter != filtered_items.end() ) {
7967 active_pos = iter->vIG[page_num].pos;
7968 activeItem = &( *iter );
7969 }
7970 }
7971
7972 if( activeItem ) {
7973 centerlistview( active_pos, width );
7974 trail_start = u.pos();
7975 trail_end = u.pos() + active_pos;
7976 // Actually accessed from the terrain overlay callback `trail_cb` in the
7977 // call to `ui_manager::redraw`.
7978 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
7979 trail_end_x = true;
7980 } else {
7981 u.view_offset = stored_view_offset;
7982 trail_start = trail_end = cata::nullopt;
7983 }
7985
7987
7988 action = ctxt.handle_input();
7989 } while( action != "QUIT" );
7990
7991 u.view_offset = stored_view_offset;
7992 return game::vmenu_ret::QUIT;
7993}
constexpr T clamp(const T &val, const T &min, const T &max)
Clamp first argument so that it is no lower than second and no higher than third.
Definition: cata_utility.h:145
std::string list_item_upvote
Definition: game.h:1079
std::string list_item_downvote
Definition: game.h:1080
std::string sFilter
Definition: game.h:1078
void reset_item_list_state(const catacurses::window &window, int height, bool bRadiusSort)
Definition: game.cpp:7436
nc_color color_in_inventory() const
Returns the color of the item depending on usefulness for the player character, e....
Definition: item.cpp:4015
static bool map_item_stack_sort(const map_item_stack &lhs, const map_item_stack &rhs)
std::vector< item_group > vIG
const item * example
string_input_popup & identifier(const std::string &value)
An identifier to be used to store / get the input history.
string_input_popup & text(const std::string &value)
Set / get the text that can be modified by the user.
void edit(std::string &value)
Edit values in place.
string_input_popup & width(int value)
Width (in console cells) of the input field itself.
string_input_popup & description(const std::string &value)
Additional help text, shown below the input box.
string_input_popup & title(const std::string &value)
The title: short string before the actual input field.
std::string list_item_priority
Definition: uistate.h:120
int list_item_sort
Definition: uistate.h:117
bool list_item_downvote_active
Definition: uistate.h:123
bool list_item_init
Definition: uistate.h:125
bool list_item_filter_active
Definition: uistate.h:122
std::string list_item_filter
Definition: uistate.h:118
bool list_item_priority_active
Definition: uistate.h:124
std::string list_item_downvote
Definition: uistate.h:119
direction direction_from(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:540
static shared_ptr_fast< game::draw_callback_t > create_trail_callback(const cata::optional< tripoint > &trail_start, const cata::optional< tripoint > &trail_end, const bool &trail_end_x)
Definition: game.cpp:3449
uistatedata uistate
Definition: game.cpp:272
static void centerlistview(const tripoint &active_item_position, int ui_width)
Definition: game.cpp:7281
std::string direction_name_short(const direction dir)
Definition: line.cpp:533
int list_filter_high_priority(std::vector< map_item_stack > &stack, const std::string &priorities)
std::vector< map_item_stack > filter_item_stacks(const std::vector< map_item_stack > &stack, const std::string &filter)
int list_filter_low_priority(std::vector< map_item_stack > &stack, const int start, const std::string &priorities)
void mvwprintw(const window &win, const point &p, const std::string &text)
void wprintw(const window &win, const std::string &text)
void calcStartPos(int &iStartPos, const int iCurrentLine, const int iContentHeight, const int iNumEntries)
Definition: output.cpp:1507
void draw_item_filter_rules(const catacurses::window &win, int starty, int height, item_filter_type type)
Write some tips (such as precede items with - to exclude them) onto the window.
Definition: output.cpp:810
void draw_scrollbar(const catacurses::window &window, const int iCurrentLine, const int iContentHeight, const int iNumLines, const point &offset, nc_color bar_color, const bool bDoNotScrollToEnd)
Draw a scrollbar (Legacy function, use class scrollbar instead!)
Definition: output.cpp:1314
std::string remove_color_tags(const std::string &s)
Removes the color tags from the input string.
Definition: output.cpp:145
void draw_custom_border(const catacurses::window &w, const catacurses::chtype ls, const catacurses::chtype rs, const catacurses::chtype ts, const catacurses::chtype bs, const catacurses::chtype tl, const catacurses::chtype tr, const catacurses::chtype bl, const catacurses::chtype br, const nc_color FG, const point &pos, int height, int width)
Definition: output.cpp:524
void trim_and_print(const catacurses::window &w, const point &begin, const int width, const nc_color &base_color, const std::string &text, const report_color_error color_error)
Prints a single line of text.
Definition: output.cpp:214
#define LINE_XOXX
Definition: output.h:47
#define LINE_XXXO
Definition: output.h:45

References _, action, add_draw_callback(), add_msg(), c_light_gray, c_light_green, c_magenta, c_red, c_white, c_yellow, calcStartPos(), centerlistview(), CHANGE_TAB, clamp(), item::color_in_inventory(), game_menus::inv::compare(), create_trail_callback(), string_input_popup::description(), direction_from(), direction_name_short(), item::display_name(), draw_custom_border(), draw_item_filter_rules(), draw_item_info(), draw_scrollbar(), string_input_popup::edit(), map_item_stack::example, FILTER, filter_item_stacks(), Character::get_path_avoid(), Character::get_pathfinding_settings(), input_context::handle_input(), item_info_data::handle_scrolling, high, HIGH_PRIORITY, string_input_popup::identifier(), item::info(), invalidate_main_ui_adaptor(), LINE_XOXX, LINE_XXXO, list_filter_high_priority(), list_filter_low_priority(), list_item_downvote, uistatedata::list_item_downvote, uistatedata::list_item_downvote_active, uistatedata::list_item_filter, uistatedata::list_item_filter_active, uistatedata::list_item_init, uistatedata::list_item_priority, uistatedata::list_item_priority_active, uistatedata::list_item_sort, list_item_upvote, LOW_PRIORITY, m, m_info, map_item_stack::map_item_stack_sort(), string_input_popup::max_length(), catacurses::mvwprintw(), mvwprintz(), catacurses::newwin(), cata::nullopt, point_south, point_zero, Character::pos(), string_input_popup::query_string(), QUIT, ui_manager::redraw(), input_context::register_action(), remove_color_tags(), reset_item_list_state(), rl_dist(), map::route(), Character::sees(), Character::set_destination(), sFilter, string_format(), TERMX, TERMY, string_input_popup::text(), string_input_popup::title(), item::tname(), to_translation(), trim_and_print(), tripoint_zero, item::type_name(), u, uistate, utf8_width(), cata::optional< T >::value(), player::view_offset, map_item_stack::vIG, catacurses::werase(), string_input_popup::width(), item_info_data::without_border, item_info_data::without_getch, catacurses::wnoutrefresh(), catacurses::wprintw(), and wprintz().

Referenced by list_items_monsters().

◆ list_items_monsters()

void game::list_items_monsters ( )
private

Definition at line 7504 of file game.cpp.

7505{
7506 std::vector<Creature *> mons = u.get_visible_creatures( current_daylight_level( calendar::turn ) );
7507 // whole reality bubble
7508 const std::vector<map_item_stack> items = find_nearby_items( 60 );
7509
7510 if( mons.empty() && items.empty() ) {
7511 add_msg( m_info, _( "You don't see any items or monsters around you!" ) );
7512 return;
7513 }
7514
7515 std::sort( mons.begin(), mons.end(), [&]( const Creature * lhs, const Creature * rhs ) {
7516 const auto att_lhs = lhs->attitude_to( u );
7517 const auto att_rhs = rhs->attitude_to( u );
7518
7519 return att_lhs < att_rhs || ( att_lhs == att_rhs
7520 && rl_dist( u.pos(), lhs->pos() ) < rl_dist( u.pos(), rhs->pos() ) );
7521 } );
7522
7523 // If the current list is empty, switch to the non-empty list
7525 if( items.empty() ) {
7526 uistate.vmenu_show_items = false;
7527 }
7528 } else if( mons.empty() ) {
7530 }
7531
7534 while( true ) {
7535 ret = uistate.vmenu_show_items ? list_items( items ) : list_monsters( mons );
7538 } else {
7539 break;
7540 }
7541 }
7542
7543 if( ret == game::vmenu_ret::FIRE ) {
7545 }
7547}
double current_daylight_level(const time_point &p)
Returns the current seasonally-adjusted maximum daylight level.
Definition: calendar.cpp:171
game::vmenu_ret list_monsters(const std::vector< Creature * > &monster_list)
Definition: game.cpp:7995
game::vmenu_ret list_items(const std::vector< map_item_stack > &item_list)
Definition: game.cpp:7549
vmenu_ret
Definition: game.h:805
std::vector< map_item_stack > find_nearby_items(int iRadius)
Definition: game.cpp:7210
void temp_exit_fullscreen()
Definition: game.cpp:538
void reenter_fullscreen()
Definition: game.cpp:548
bool vmenu_show_items
Definition: uistate.h:121

References _, add_msg(), CHANGE_TAB, current_daylight_level(), find_nearby_items(), FIRE, avatar_action::fire_wielded_weapon(), Character::get_visible_creatures(), list_items(), list_monsters(), m_info, reenter_fullscreen(), cata::hash64_detail::ret, temp_exit_fullscreen(), calendar::turn, u, uistate, and uistatedata::vmenu_show_items.

Referenced by handle_action(), and look_around().

◆ list_missions()

void game::list_missions ( )

Definition at line 22 of file mission_ui.cpp.

23{
24 catacurses::window w_missions;
25
26 enum class tab_mode : int {
27 TAB_ACTIVE = 0,
28 TAB_COMPLETED,
29 TAB_FAILED,
30 NUM_TABS,
31 FIRST_TAB = 0,
32 LAST_TAB = NUM_TABS - 1
33 };
34 tab_mode tab = tab_mode::FIRST_TAB;
35 size_t selection = 0;
36 int entries_per_page = 0;
37 input_context ctxt( "MISSIONS" );
38 ctxt.register_cardinal();
39 ctxt.register_action( "CONFIRM" );
40 ctxt.register_action( "QUIT" );
41 ctxt.register_action( "HELP_KEYBINDINGS" );
42
44 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
46
47 // content ranges from y=3 to FULL_SCREEN_HEIGHT - 2
48 entries_per_page = FULL_SCREEN_HEIGHT - 4;
49
50 ui.position_from_window( w_missions );
51 } );
52 ui.mark_resize();
53
54 std::vector<mission *> umissions;
55
56 ui.on_redraw( [&]( const ui_adaptor & ) {
57 werase( w_missions );
58 // entries_per_page * page number
59 const int top_of_page = entries_per_page * ( selection / entries_per_page );
60 const int bottom_of_page =
61 std::min( top_of_page + entries_per_page - 1, static_cast<int>( umissions.size() ) - 1 );
62
63 for( int i = 3; i < FULL_SCREEN_HEIGHT - 1; i++ ) {
64 mvwputch( w_missions, point( 30, i ), BORDER_COLOR, LINE_XOXO );
65 }
66
67 const std::vector<std::pair<tab_mode, std::string>> tabs = {
68 { tab_mode::TAB_ACTIVE, _( "ACTIVE MISSIONS" ) },
69 { tab_mode::TAB_COMPLETED, _( "COMPLETED MISSIONS" ) },
70 { tab_mode::TAB_FAILED, _( "FAILED MISSIONS" ) },
71 };
72 draw_tabs( w_missions, tabs, tab );
73 draw_border_below_tabs( w_missions );
74
75 mvwputch( w_missions, point( 30, 2 ), BORDER_COLOR,
76 tab == tab_mode::TAB_COMPLETED ? ' ' : LINE_OXXX ); // ^|^
77 mvwputch( w_missions, point( 30, FULL_SCREEN_HEIGHT - 1 ), BORDER_COLOR, LINE_XXOX ); // _|_
78
79 draw_scrollbar( w_missions, selection, entries_per_page, umissions.size(), point( 0, 3 ) );
80
81 for( int i = top_of_page; i <= bottom_of_page; i++ ) {
82 const auto miss = umissions[i];
83 const nc_color col = u.get_active_mission() == miss ? c_light_green : c_white;
84 const int y = i - top_of_page + 3;
85 trim_and_print( w_missions, point( 1, y ), 28,
86 static_cast<int>( selection ) == i ? hilite( col ) : col,
87 miss->name() );
88 }
89
90 if( selection < umissions.size() ) {
91 const auto miss = umissions[selection];
92 const nc_color col = u.get_active_mission() == miss ? c_light_green : c_white;
93 std::string for_npc;
94 if( miss->get_npc_id().is_valid() ) {
95 npc *guy = g->find_npc( miss->get_npc_id() );
96 if( guy ) {
97 for_npc = string_format( _( " for %s" ), guy->disp_name() );
98 }
99 }
100
101 int y = 3;
102 y += fold_and_print( w_missions, point( 31, y ), getmaxx( w_missions ) - 33, col,
103 miss->name() + for_npc );
104
105 auto format_tokenized_description = []( const std::string & description,
106 const std::vector<std::pair<int, itype_id>> &rewards ) {
107 std::string formatted_description = description;
108 for( const auto &reward : rewards ) {
109 std::string token = "<reward_count:" + reward.second.str() + ">";
110 formatted_description = replace_all( formatted_description, token,
111 string_format( "%d", reward.first ) );
112 }
113 return formatted_description;
114 };
115
116 y++;
117 if( !miss->get_description().empty() ) {
118 y += fold_and_print( w_missions, point( 31, y ), getmaxx( w_missions ) - 33, c_white,
119 format_tokenized_description( miss->get_description(), miss->get_likely_rewards() ) );
120 }
121 if( miss->has_deadline() ) {
122 const time_point deadline = miss->get_deadline();
123 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Deadline: %s" ), to_string( deadline ) );
124
125 if( tab != tab_mode::TAB_COMPLETED ) {
126 // There's no point in displaying this for a completed mission.
127 // @ TODO: But displaying when you completed it would be useful.
128 const time_duration remaining = deadline - calendar::turn;
129 std::string remaining_time;
130
131 if( remaining <= 0_turns ) {
132 remaining_time = _( "None!" );
133 } else if( u.has_watch() ) {
134 remaining_time = to_string( remaining );
135 } else {
136 remaining_time = to_string_approx( remaining );
137 }
138
139 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Time remaining: %s" ), remaining_time );
140 }
141 }
142 if( miss->has_target() ) {
144 // TODO: target does not contain a z-component, targets are assumed to be on z=0
145 mvwprintz( w_missions, point( 31, ++y ), c_white, _( "Target: %s You: %s" ),
146 miss->get_target().to_string(), pos.to_string() );
147 }
148 } else {
149 static const std::map< tab_mode, std::string > nope = {
150 { tab_mode::TAB_ACTIVE, translate_marker( "You have no active missions!" ) },
151 { tab_mode::TAB_COMPLETED, translate_marker( "You haven't completed any missions!" ) },
152 { tab_mode::TAB_FAILED, translate_marker( "You haven't failed any missions!" ) }
153 };
154 mvwprintz( w_missions, point( 31, 4 ), c_light_red, _( nope.at( tab ) ) );
155 }
156
157 wnoutrefresh( w_missions );
158 } );
159
160 while( true ) {
161 umissions.clear();
162 if( tab < tab_mode::FIRST_TAB || tab >= tab_mode::NUM_TABS ) {
163 debugmsg( "The sanity check failed because tab=%d", static_cast<int>( tab ) );
164 tab = tab_mode::FIRST_TAB;
165 }
166 switch( tab ) {
168 umissions = u.get_active_missions();
169 break;
170 case tab_mode::TAB_COMPLETED:
171 umissions = u.get_completed_missions();
172 break;
173 case tab_mode::TAB_FAILED:
174 umissions = u.get_failed_missions();
175 break;
176 default:
177 break;
178 }
179 if( ( !umissions.empty() && selection >= umissions.size() ) ||
180 ( umissions.empty() && selection != 0 ) ) {
181 debugmsg( "Sanity check failed: selection=%d, size=%d", static_cast<int>( selection ),
182 static_cast<int>( umissions.size() ) );
183 selection = 0;
184 }
186 const std::string action = ctxt.handle_input();
187 if( action == "RIGHT" ) {
188 tab = static_cast<tab_mode>( static_cast<int>( tab ) + 1 );
189 if( tab >= tab_mode::NUM_TABS ) {
190 tab = tab_mode::FIRST_TAB;
191 }
192 selection = 0;
193 } else if( action == "LEFT" ) {
194 tab = static_cast<tab_mode>( static_cast<int>( tab ) - 1 );
195 if( tab < tab_mode::FIRST_TAB ) {
196 tab = tab_mode::LAST_TAB;
197 }
198 selection = 0;
199 } else if( action == "DOWN" ) {
200 selection++;
201 if( selection >= umissions.size() ) {
202 selection = 0;
203 }
204 } else if( action == "UP" ) {
205 if( selection == 0 ) {
206 selection = umissions.empty() ? 0 : umissions.size() - 1;
207 } else {
208 selection--;
209 }
210 } else if( action == "CONFIRM" ) {
211 if( tab == tab_mode::TAB_ACTIVE && selection < umissions.size() ) {
212 u.set_active_mission( *umissions[selection] );
213 }
214 break;
215 } else if( action == "QUIT" ) {
216 break;
217 }
218 }
219}
std::string to_string_approx(const time_duration &dur, const bool verbose)
Returns approximate duration.
Definition: calendar.cpp:361
bool has_watch() const
Returns true if the player or their vehicle has a watch.
Definition: character.cpp:844
void set_active_mission(mission &cur_mission)
Set which mission is active.
Definition: avatar.cpp:206
mission * get_active_mission() const
Returns the mission that is currently active.
Definition: avatar.cpp:185
std::vector< mission * > get_completed_missions() const
Definition: avatar.cpp:175
std::vector< mission * > get_active_missions() const
Definition: avatar.cpp:170
std::vector< mission * > get_failed_missions() const
Definition: avatar.cpp:180
A point in the game time.
Definition: calendar.h:431
nc_color hilite(const nc_color &c)
Definition: color.cpp:509
void draw_tabs(const catacurses::window &w, const std::vector< std::string > &tab_texts, size_t current_tab)
Definition: output.cpp:1274
void draw_border_below_tabs(const catacurses::window &w, nc_color border_color)
Definition: output.cpp:587
int fold_and_print(const catacurses::window &w, const point &begin, int width, const nc_color &base_color, const std::string &text, const char split)
Fold and print text in the given window.
Definition: output.cpp:299
#define LINE_XXOX
Definition: output.h:46
std::string replace_all(std::string input, const std::string &what, const std::string &with)
Replace all occurences of 'what' within 'input' with 'with'.
#define translate_marker(x)
Marks a string literal to be extracted for translation.
Definition: translations.h:30
catacurses::window new_centered_win(int nlines, int ncols)
Definition: ui.cpp:30

References _, action, BORDER_COLOR, c_light_green, c_light_red, c_white, debugmsg, Character::disp_name(), draw_border_below_tabs(), draw_scrollbar(), draw_tabs(), fold_and_print(), FULL_SCREEN_HEIGHT, FULL_SCREEN_WIDTH, g, avatar::get_active_mission(), avatar::get_active_missions(), avatar::get_completed_missions(), avatar::get_failed_missions(), catacurses::getmaxx(), Character::global_omt_location(), input_context::handle_input(), Character::has_watch(), hilite(), LINE_OXXX, LINE_XOXO, LINE_XXOX, mvwprintz(), mvwputch(), new_centered_win(), ui_manager::redraw(), input_context::register_action(), input_context::register_cardinal(), replace_all(), avatar::set_active_mission(), string_format(), anonymous_namespace{bionics_ui.cpp}::TAB_ACTIVE, coords::coord_point< Point, Origin, Scale >::to_string(), to_string(), to_string_approx(), translate_marker, trim_and_print(), calendar::turn, u, catacurses::werase(), and catacurses::wnoutrefresh().

Referenced by handle_action().

◆ list_monsters()

game::vmenu_ret game::list_monsters ( const std::vector< Creature * > &  monster_list)
private

Definition at line 7995 of file game.cpp.

7996{
7997 const int iInfoHeight = 15;
7998 const int width = 45;
7999 int offsetX = 0;
8000 int iMaxRows = 0;
8001
8002 catacurses::window w_monsters;
8003 catacurses::window w_monsters_border;
8004 catacurses::window w_monster_info;
8005 catacurses::window w_monster_info_border;
8006
8007 Creature *cCurMon = nullptr;
8008 tripoint iActivePos;
8009
8010 bool hide_ui = false;
8011
8012 ui_adaptor ui;
8013 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
8014 if( hide_ui ) {
8015 ui.position( point_zero, point_zero );
8016 } else {
8017 offsetX = TERMX - width;
8018 iMaxRows = TERMY - iInfoHeight - 1;
8019
8020 w_monsters = catacurses::newwin( iMaxRows, width - 2, point( offsetX + 1,
8021 1 ) );
8022 w_monsters_border = catacurses::newwin( iMaxRows + 1, width, point( offsetX,
8023 0 ) );
8024 w_monster_info = catacurses::newwin( iInfoHeight - 2, width - 2,
8025 point( offsetX + 1, TERMY - iInfoHeight + 1 ) );
8026 w_monster_info_border = catacurses::newwin( iInfoHeight, width, point( offsetX,
8027 TERMY - iInfoHeight ) );
8028
8029 if( cCurMon ) {
8030 centerlistview( iActivePos, width );
8031 }
8032
8033 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
8034 }
8035 } );
8036 ui.mark_resize();
8037
8038 const int max_gun_range = u.weapon.gun_range( &u );
8039
8040 const tripoint stored_view_offset = u.view_offset;
8042
8043 int iActive = 0; // monster index that we're looking at
8044
8045 std::string action;
8046 input_context ctxt( "LIST_MONSTERS" );
8047 ctxt.register_action( "UP", to_translation( "Move cursor up" ) );
8048 ctxt.register_action( "DOWN", to_translation( "Move cursor down" ) );
8049 ctxt.register_action( "NEXT_TAB" );
8050 ctxt.register_action( "PREV_TAB" );
8051 ctxt.register_action( "SAFEMODE_BLACKLIST_ADD" );
8052 ctxt.register_action( "SAFEMODE_BLACKLIST_REMOVE" );
8053 ctxt.register_action( "QUIT" );
8054 if( bVMonsterLookFire ) {
8055 ctxt.register_action( "look" );
8056 ctxt.register_action( "fire" );
8057 }
8058 ctxt.register_action( "HELP_KEYBINDINGS" );
8059
8060 // first integer is the row the attitude category string is printed in the menu
8061 std::map<int, Creature::Attitude> mSortCategory;
8062
8063 for( int i = 0, last_attitude = -1; i < static_cast<int>( monster_list.size() ); i++ ) {
8064 const auto attitude = monster_list[i]->attitude_to( u );
8065 if( attitude != last_attitude ) {
8066 mSortCategory[i + mSortCategory.size()] = attitude;
8067 last_attitude = attitude;
8068 }
8069 }
8070
8071 ui.on_redraw( [&]( const ui_adaptor & ) {
8072 if( !hide_ui ) {
8073 draw_custom_border( w_monsters_border, true, true, true, true, true, true, LINE_XOXO, LINE_XOXO );
8074 draw_custom_border( w_monster_info_border, true, true, true, true, LINE_XXXO, LINE_XOXX, true,
8075 true );
8076
8077 mvwprintz( w_monsters_border, point( 2, 0 ), c_light_green, "<Tab> " );
8078 wprintz( w_monsters_border, c_white, _( "Monsters" ) );
8079
8080 if( monster_list.empty() ) {
8081 werase( w_monsters );
8082 mvwprintz( w_monsters, point( 2, iMaxRows / 3 ), c_white,
8083 _( "You don't see any monsters around you!" ) );
8084 } else {
8085 werase( w_monsters );
8086
8087 const int iNumMonster = monster_list.size();
8088 const int iMenuSize = monster_list.size() + mSortCategory.size();
8089
8090 const int numw = iNumMonster > 999 ? 4 :
8091 iNumMonster > 99 ? 3 :
8092 iNumMonster > 9 ? 2 : 1;
8093
8094 // given the currently selected monster iActive. get the selected row
8095 int iSelPos = iActive;
8096 for( auto &ia : mSortCategory ) {
8097 int index = ia.first;
8098 if( index <= iSelPos ) {
8099 ++iSelPos;
8100 } else {
8101 break;
8102 }
8103 }
8104 int iStartPos = 0;
8105 // use selected row get the start row
8106 calcStartPos( iStartPos, iSelPos, iMaxRows - 1, iMenuSize );
8107
8108 // get first visible monster and category
8109 int iCurMon = iStartPos;
8110 auto CatSortIter = mSortCategory.cbegin();
8111 while( CatSortIter != mSortCategory.cend() && CatSortIter->first < iStartPos ) {
8112 ++CatSortIter;
8113 --iCurMon;
8114 }
8115
8116 const auto endY = std::min<int>( iMaxRows - 1, iMenuSize );
8117 for( int y = 0; y < endY; ++y ) {
8118 if( CatSortIter != mSortCategory.cend() ) {
8119 const int iCurPos = iStartPos + y;
8120 const int iCatPos = CatSortIter->first;
8121 if( iCurPos == iCatPos ) {
8122 const std::string cat_name = Creature::get_attitude_ui_data(
8123 CatSortIter->second ).first.translated();
8124 mvwprintz( w_monsters, point( 1, y ), c_magenta, cat_name );
8125 ++CatSortIter;
8126 continue;
8127 }
8128 }
8129 // select current monster
8130 const auto critter = monster_list[iCurMon];
8131 const bool selected = iCurMon == iActive;
8132 ++iCurMon;
8133 if( critter->sees( g->u ) ) {
8134 mvwprintz( w_monsters, point( 0, y ), c_yellow, "!" );
8135 }
8136 bool is_npc = false;
8137 const monster *m = dynamic_cast<monster *>( critter );
8138 const npc *p = dynamic_cast<npc *>( critter );
8139 nc_color name_color = critter->basic_symbol_color();
8140
8141 if( selected ) {
8142 name_color = hilite( name_color );
8143 }
8144
8145 if( m != nullptr ) {
8146 trim_and_print( w_monsters, point( 1, y ), width - 26, name_color, m->name() );
8147 } else {
8148 trim_and_print( w_monsters, point( 1, y ), width - 26, name_color, critter->disp_name() );
8149 is_npc = true;
8150 }
8151
8152 if( selected && !get_safemode().empty() ) {
8153 const std::string monName = is_npc ? get_safemode().npc_type_name() : m->name();
8154
8155 std::string sSafemode;
8156 if( get_safemode().has_rule( monName, Creature::A_ANY ) ) {
8157 sSafemode = _( "<R>emove from safemode Blacklist" );
8158 } else {
8159 sSafemode = _( "<A>dd to safemode Blacklist" );
8160 }
8161
8162 shortcut_print( w_monsters, point( 2, getmaxy( w_monsters ) - 1 ),
8163 c_white, c_light_green, sSafemode );
8164 }
8165
8167 std::string sText;
8168
8169 if( m != nullptr ) {
8170 m->get_HP_Bar( color, sText );
8171 } else {
8172 std::tie( sText, color ) =
8173 ::get_hp_bar( critter->get_hp(), critter->get_hp_max(), false );
8174 }
8175 mvwprintz( w_monsters, point( width - 25, y ), color, sText );
8176
8177 if( m != nullptr ) {
8178 const auto att = m->get_attitude();
8179 sText = att.first;
8180 color = att.second;
8181 } else if( p != nullptr ) {
8182 sText = npc_attitude_name( p->get_attitude() );
8183 color = p->symbol_color();
8184 }
8185 mvwprintz( w_monsters, point( width - 19, y ), color, sText );
8186
8187 const int mon_dist = rl_dist( u.pos(), critter->pos() );
8188 const int numd = mon_dist > 999 ? 4 :
8189 mon_dist > 99 ? 3 :
8190 mon_dist > 9 ? 2 : 1;
8191
8192 trim_and_print( w_monsters, point( width - ( 8 + numd ), y ), 6 + numd,
8193 selected ? c_light_green : c_light_gray,
8194 "%*d %s",
8195 numd, mon_dist,
8196 direction_name_short( direction_from( u.pos(), critter->pos() ) ) );
8197 }
8198
8199 mvwprintz( w_monsters_border, point( ( width / 2 ) - numw - 2, 0 ), c_light_green, " %*d", numw,
8200 iActive + 1 );
8201 wprintz( w_monsters_border, c_white, " / %*d ", numw, static_cast<int>( monster_list.size() ) );
8202
8203 werase( w_monster_info );
8204 if( cCurMon ) {
8205 cCurMon->print_info( w_monster_info, 1, iInfoHeight - 3, 1 );
8206 }
8207
8208 draw_custom_border( w_monster_info_border, true, true, true, true, LINE_XXXO, LINE_XOXX, true,
8209 true );
8210
8211 if( bVMonsterLookFire ) {
8212 mvwprintw( w_monster_info_border, point_east, "< " );
8213 wprintz( w_monster_info_border, c_light_green, ctxt.press_x( "look" ) );
8214 wprintz( w_monster_info_border, c_light_gray, " %s", _( "to look around" ) );
8215
8216 if( cCurMon && rl_dist( u.pos(), cCurMon->pos() ) <= max_gun_range ) {
8217 wprintw( w_monster_info_border, " " );
8218 wprintz( w_monster_info_border, c_light_green, ctxt.press_x( "fire" ) );
8219 wprintz( w_monster_info_border, c_light_gray, " %s", _( "to shoot" ) );
8220 }
8221 wprintw( w_monster_info_border, " >" );
8222 }
8223
8224 draw_scrollbar( w_monsters_border, iActive, iMaxRows, static_cast<int>( monster_list.size() ),
8225 point_south );
8226 }
8227
8228 wnoutrefresh( w_monsters_border );
8229 wnoutrefresh( w_monster_info_border );
8230 wnoutrefresh( w_monsters );
8231 wnoutrefresh( w_monster_info );
8232 }
8233 } );
8234
8235 cata::optional<tripoint> trail_start;
8236 cata::optional<tripoint> trail_end;
8237 bool trail_end_x = false;
8238 shared_ptr_fast<draw_callback_t> trail_cb = create_trail_callback( trail_start, trail_end,
8239 trail_end_x );
8240 add_draw_callback( trail_cb );
8241
8242 do {
8243 if( action == "UP" ) {
8244 iActive--;
8245 if( iActive < 0 ) {
8246 if( monster_list.empty() ) {
8247 iActive = 0;
8248 } else {
8249 iActive = static_cast<int>( monster_list.size() ) - 1;
8250 }
8251 }
8252 } else if( action == "DOWN" ) {
8253 iActive++;
8254 if( iActive >= static_cast<int>( monster_list.size() ) ) {
8255 iActive = 0;
8256 }
8257 } else if( action == "NEXT_TAB" || action == "PREV_TAB" ) {
8258 u.view_offset = stored_view_offset;
8260 } else if( action == "SAFEMODE_BLACKLIST_REMOVE" ) {
8261 const auto m = dynamic_cast<monster *>( cCurMon );
8262 const std::string monName = ( m != nullptr ) ? m->name() : "human";
8263
8264 if( get_safemode().has_rule( monName, Creature::A_ANY ) ) {
8266 }
8267 } else if( action == "SAFEMODE_BLACKLIST_ADD" ) {
8268 if( !get_safemode().empty() ) {
8269 const auto m = dynamic_cast<monster *>( cCurMon );
8270 const std::string monName = ( m != nullptr ) ? m->name() : "human";
8271
8272 get_safemode().add_rule( monName, Creature::A_ANY, get_option<int>( "SAFEMODEPROXIMITY" ),
8274 }
8275 } else if( action == "look" ) {
8276 hide_ui = true;
8277 ui.mark_resize();
8278 look_around();
8279 hide_ui = false;
8280 ui.mark_resize();
8281 } else if( action == "fire" ) {
8282 if( cCurMon != nullptr && rl_dist( u.pos(), cCurMon->pos() ) <= max_gun_range ) {
8283 u.last_target = shared_from( *cCurMon );
8285 u.view_offset = stored_view_offset;
8286 return game::vmenu_ret::FIRE;
8287 }
8288 }
8289
8290 if( iActive >= 0 && static_cast<size_t>( iActive ) < monster_list.size() ) {
8291 cCurMon = monster_list[iActive];
8292 iActivePos = cCurMon->pos() - u.pos();
8293 centerlistview( iActivePos, width );
8294 trail_start = u.pos();
8295 trail_end = cCurMon->pos();
8296 // Actually accessed from the terrain overlay callback `trail_cb` in the
8297 // call to `ui_manager::redraw`.
8298 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
8299 trail_end_x = false;
8300 } else {
8301 cCurMon = nullptr;
8302 iActivePos = tripoint_zero;
8303 u.view_offset = stored_view_offset;
8304 trail_start = trail_end = cata::nullopt;
8305 }
8307
8309
8310 action = ctxt.handle_input();
8311 } while( action != "QUIT" );
8312
8313 u.view_offset = stored_view_offset;
8314
8315 return game::vmenu_ret::QUIT;
8316}
double recoil
Definition: character.h:560
nc_color symbol_color() const override
Color's character's tile's background.
Definition: character.cpp:6124
static const std::pair< translation, nc_color > & get_attitude_ui_data(Attitude att)
Creature Attitude as String and color.
Definition: creature.cpp:1860
virtual const tripoint & pos() const =0
virtual int print_info(const catacurses::window &w, int vStart, int vLines, int column) const =0
Write information about this creature.
shared_ptr_fast< T > shared_from(const T &critter)
Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature).
Definition: game.cpp:4904
bool bVMonsterLookFire
Definition: game.h:1083
int gun_range(const player *p) const
The weapons range in map squares.
Definition: item.cpp:7195
npc_attitude get_attitude() const
Definition: npc.cpp:3136
weak_ptr_fast< Creature > last_target
Definition: player.h:647
bool has_rule(const std::string &rule_in, Creature::Attitude attitude_in)
void remove_rule(const std::string &rule_in, Creature::Attitude attitude_in)
static nc_color color(const T_t &t)
@ RULE_BLACKLISTED
Definition: enums.h:54
constexpr double MAX_RECOIL
std::string npc_attitude_name(npc_attitude att)
Definition: npc.cpp:2542
std::pair< std::string, nc_color > get_hp_bar(const int cur_hp, const int max_hp, const bool is_mon)
Definition: output.cpp:1604
size_t shortcut_print(const catacurses::window &w, const point &p, nc_color text_color, nc_color shortcut_color, const std::string &fmt)
Definition: output.cpp:1543

References _, Creature::A_ANY, action, add_draw_callback(), safemode::add_rule(), bVMonsterLookFire, c_light_gray, c_light_green, c_magenta, c_white, c_yellow, calcStartPos(), centerlistview(), CHANGE_TAB, color(), create_trail_callback(), direction_from(), direction_name_short(), draw_custom_border(), draw_scrollbar(), FIRE, g, npc::get_attitude(), Creature::get_attitude_ui_data(), get_hp_bar(), get_safemode(), catacurses::getmaxy(), item::gun_range(), input_context::handle_input(), safemode::has_rule(), hilite(), invalidate_main_ui_adaptor(), player::last_target, LINE_XOXO, LINE_XOXX, LINE_XXXO, look_around(), m, MAX_RECOIL, catacurses::mvwprintw(), mvwprintz(), map::name(), catacurses::newwin(), npc_attitude_name(), safemode::npc_type_name(), cata::nullopt, point_east, point_south, point_zero, Creature::pos(), Character::pos(), input_context::press_x(), Creature::print_info(), QUIT, Character::recoil, ui_manager::redraw(), input_context::register_action(), safemode::remove_rule(), rl_dist(), RULE_BLACKLISTED, shared_from(), shortcut_print(), Character::symbol_color(), TERMX, TERMY, to_translation(), trim_and_print(), tripoint_zero, u, player::view_offset, Character::weapon, catacurses::werase(), catacurses::wnoutrefresh(), catacurses::wprintw(), and wprintz().

Referenced by list_items_monsters().

◆ load() [1/2]

bool game::load ( const save_t name)
private

Definition at line 2857 of file game.cpp.

2858{
2861 popup.message( "%s", _( "Please wait…\nLoading the save…" ) );
2864
2865 using namespace std::placeholders;
2866
2867 const std::string worldpath = get_world_base_save_path() + "/";
2868 const std::string playerpath = worldpath + name.base_path();
2869
2870 // Now load up the master game data; factions (and more?)
2871 load_master();
2872 u = avatar();
2873 u.name = name.player_name();
2874 // This should be initialized more globally (in player/Character constructor)
2876 if( !read_from_file( playerpath + SAVE_EXTENSION, std::bind( &game::unserialize, this, _1 ) ) ) {
2877 return false;
2878 }
2879
2881
2883
2884 read_from_file_optional( worldpath + name.base_path() + SAVE_EXTENSION_LOG,
2885 std::bind( &memorial_logger::load, &memorial(), _1 ) );
2886
2887#if defined(__ANDROID__)
2888 read_from_file_optional( worldpath + name.base_path() + SAVE_EXTENSION_SHORTCUTS,
2889 std::bind( &game::load_shortcuts, this, _1 ) );
2890#endif
2891
2892 // Now that the player's worn items are updated, their sight limits need to be
2893 // recalculated. (This would be cleaner if u.worn were private.)
2895
2896 if( !gamemode ) {
2897 gamemode = std::make_unique<special_game>();
2898 }
2899
2900 safe_mode = get_option<bool>( "SAFEMODE" ) ? SAFE_MODE_ON : SAFE_MODE_OFF;
2901 mostseen = 0; // ...and mostseen is 0, we haven't seen any monsters yet.
2902
2903 init_autosave();
2904 get_auto_pickup().load_character(); // Load character auto pickup rules
2905 get_auto_notes_settings().load(); // Load character auto notes settings
2906 get_safemode().load_character(); // Load character safemode rules
2907 zone_manager::get_manager().load_zones(); // Load character world zones
2908 read_from_file_optional( get_world_base_save_path() + "/uistate.json", []( std::istream & stream ) {
2909 JsonIn jsin( stream );
2910 uistate.deserialize( jsin );
2911 } );
2912 reload_npcs();
2917 update_map( u );
2918 for( auto &e : u.inv_dump() ) {
2919 e->set_owner( g->u );
2920 }
2921 // legacy, needs to be here as we access the map.
2922 if( !u.getID().is_valid() ) {
2923 // player does not have a real id, so assign a new one,
2924 u.setID( assign_npc_id() );
2925 // The vehicle stores the IDs of the boarded players, so update it, too.
2926 if( u.in_vehicle ) {
2928 u.pos() ).part_with_feature( "BOARDABLE", true ) ) {
2929 vp->part().passenger_id = u.getID();
2930 }
2931 }
2932 }
2933
2934 // populate calendar caches now, after active world is set, but before we do
2935 // anything else, to ensure they pick up the correct value from the save's
2936 // worldoptions
2937 calendar::set_eternal_season( ::get_option<bool>( "ETERNAL_SEASON" ) );
2938 calendar::set_season_length( ::get_option<int>( "SEASON_LENGTH" ) );
2939
2940 u.reset();
2941
2942 return true;
2943}
bool read_from_file(const std::string &path, const std::function< void(std::istream &)> &reader)
Try to open and read from given file using the given callback.
bool read_from_file_optional(const std::string &path, const std::function< void(std::istream &)> &reader)
void setID(character_id i, bool force=false)
Definition: character.cpp:466
std::vector< item * > inv_dump()
Definition: character.cpp:8973
void recalc_sight_limits()
Modifies the player's sight values Must be called when any of the following change: This must be call...
Definition: character.cpp:1706
void reset() override
Handles stat and bonus reset.
Definition: character.cpp:3625
Definition: json.h:177
Definition: avatar.h:54
void load_map_memory()
Definition: avatar.cpp:134
bool is_valid() const
Definition: character_id.h:19
void validate_linked_vehicles()
validate towed vehicles so they get linked up again after a load
Definition: game.cpp:1980
void reload_npcs()
Unloads, then loads the NPCs.
Definition: game.cpp:960
void validate_camps()
validate camps to ensure they are on the overmap list
Definition: game.cpp:2038
void load_master()
Definition: game.cpp:2826
void validate_mounted_npcs()
Definition: game.cpp:1995
character_id assign_npc_id()
Definition: game.cpp:3943
void unserialize(std::istream &fin)
Definition: savegame.cpp:167
void init_autosave()
Definition: game.cpp:11826
void validate_npc_followers()
validate list of followers to account for overmap buffers
Definition: game.cpp:2014
void load(std::istream &fin)
Loads the data in a memorial file from the given ifstream.
void load_character()
Create a popup on the UI stack that gets displayed but receives no input itself.
Definition: popup.h:276
void deserialize(const JsonObject &jo)
time_point nextweather
Definition: weather.h:205
void load_zones()
Definition: clzones.cpp:1216
static const std::string SAVE_EXTENSION(".sav")
static const std::string SAVE_EXTENSION_SHORTCUTS(".shortcuts")
static const std::string SAVE_EXTENSION_LOG(".log")
void set_season_length(int dur)
Definition: calendar.cpp:478
void set_eternal_season(bool is_eternal_season)
Definition: calendar.cpp:470

References _, assign_npc_id(), uistatedata::deserialize(), g, gamemode, get_auto_notes_settings(), get_auto_pickup(), zone_manager::get_manager(), get_safemode(), get_weather, get_world_base_save_path(), Character::getID(), Character::in_vehicle, init_autosave(), Character::inv_dump(), character_id::is_valid(), auto_notes::auto_note_settings::load(), memorial_logger::load(), auto_pickup::player_settings::load_character(), safemode::load_character(), avatar::load_map_memory(), load_master(), zone_manager::load_zones(), m, memorial(), mostseen, Character::name, om_direction::name(), weather_manager::nextweather, optional_vpart_position::part_with_feature(), popup(), Character::pos(), read_from_file(), read_from_file_optional(), Character::recalc_sight_limits(), ui_manager::redraw(), refresh_display(), reload_npcs(), Character::reset(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAVE_EXTENSION(), SAVE_EXTENSION_LOG(), SAVE_EXTENSION_SHORTCUTS(), calendar::set_eternal_season(), calendar::set_season_length(), Character::setID(), calendar::start_of_cataclysm, calendar::turn, u, uistate, unserialize(), update_map(), validate_camps(), validate_linked_vehicles(), validate_mounted_npcs(), validate_npc_followers(), map::veh_at(), and Character::weapon.

◆ load() [2/2]

bool game::load ( const std::string &  world)

Attempt to load first valid save (if any) in world.

Definition at line 2833 of file game.cpp.

2834{
2835 world_generator->init();
2836 const WORLDPTR wptr = world_generator->get_world( world );
2837 if( !wptr ) {
2838 return false;
2839 }
2840 if( wptr->world_saves.empty() ) {
2841 debugmsg( "world '%s' contains no saves", world );
2842 return false;
2843 }
2844
2845 try {
2846 world_generator->set_active_world( wptr );
2847 g->setup();
2848 g->load( wptr->world_saves.front() );
2849 } catch( const std::exception &err ) {
2850 debugmsg( "cannot load world '%s': %s", world, err.what() );
2851 return false;
2852 }
2853
2854 return true;
2855}
std::vector< save_t > world_saves
Definition: worldfactory.h:61

References debugmsg, g, world_generator, and WORLD::world_saves.

Referenced by quickload().

◆ load_core_data()

void game::load_core_data ( loading_ui ui)

Loads core dynamic data.

May throw.

Definition at line 438 of file game.cpp.

439{
440 // core data can be loaded only once and must be first
441 // anyway.
443
445}
void unload_data()
Deletes and unloads all the data previously loaded with load_data_from_path.
Definition: init.cpp:524
std::string jsondir()
Definition: path_info.cpp:230

References DynamicDataLoader::get_instance(), PATH_INFO::jsondir(), load_data_from_dir(), and DynamicDataLoader::unload_data().

Referenced by check_mod_data(), dump_stats(), and setup().

◆ load_data_from_dir()

void game::load_data_from_dir ( const std::string &  path,
const std::string &  src,
loading_ui ui 
)
protected

Loads dynamic data from the given directory.

May throw.

Definition at line 447 of file game.cpp.

448{
450}
void load_data_from_path(const std::string &path, const std::string &src, loading_ui &ui)
Load all data from json files located in the path (recursive).
Definition: init.cpp:454

References DynamicDataLoader::get_instance(), and DynamicDataLoader::load_data_from_path().

Referenced by check_mod_data(), load_core_data(), and load_packs().

◆ load_map() [1/2]

void game::load_map ( const tripoint pos_sm)

Load the main map at given location, see map::load, in global, absolute submap coordinates.

Definition at line 634 of file game.cpp.

635{
636 // TODO: fix point types
637 load_map( tripoint_abs_sm( pos_sm ) );
638}
void load_map(const tripoint &pos_sm)
Load the main map at given location, see map::load, in global, absolute submap coordinates.
Definition: game.cpp:634
coords::coord_point< tripoint, coords::origin::abs, coords::sm > tripoint_abs_sm
Definition: coordinates.h:490

References load_map().

Referenced by load_map(), place_player_overmap(), start_game(), and unserialize().

◆ load_map() [2/2]

void game::load_map ( const tripoint_abs_sm pos_sm)

Definition at line 640 of file game.cpp.

641{
642 m.load( pos_sm, true );
643 grid_tracker_ptr->load( m );
644}
void load(const tripoint &w, bool update_vehicles)
Load submaps into grid.
Definition: map.cpp:6591

References grid_tracker_ptr, map::load(), and m.

◆ load_master()

void game::load_master ( )
private

Definition at line 2826 of file game.cpp.

2827{
2828 using namespace std::placeholders;
2829 const auto datafile = get_world_base_save_path() + "/" + SAVE_MASTER;
2830 read_from_file_optional( datafile, std::bind( &game::unserialize_master, this, _1 ) );
2831}
void unserialize_master(std::istream &fin)
Definition: savegame.cpp:1188
static const std::string SAVE_MASTER("master.gsav")

References get_world_base_save_path(), read_from_file_optional(), SAVE_MASTER(), and unserialize_master().

Referenced by load(), and start_game().

◆ load_npcs()

void game::load_npcs ( )

Makes any nearby NPCs on the overmap active.

Definition at line 898 of file game.cpp.

899{
900 const int radius = HALF_MAPSIZE - 1;
901 // uses submap coordinates
902 std::vector<shared_ptr_fast<npc>> just_added;
903 for( const auto &temp : overmap_buffer.get_npcs_near_player( radius ) ) {
904 const character_id &id = temp->getID();
905 const auto found = std::find_if( active_npc.begin(), active_npc.end(),
906 [id]( const shared_ptr_fast<npc> &n ) {
907 return n->getID() == id;
908 } );
909 if( found != active_npc.end() ) {
910 continue;
911 }
912 if( temp->is_active() ) {
913 continue;
914 }
915 if( temp->has_companion_mission() ) {
916 continue;
917 }
918
919 const tripoint sm_loc = temp->global_sm_location();
920 // NPCs who are out of bounds before placement would be pushed into bounds
921 // This can cause NPCs to teleport around, so we don't want that
922 if( sm_loc.x < get_levx() || sm_loc.x >= get_levx() + MAPSIZE ||
923 sm_loc.y < get_levy() || sm_loc.y >= get_levy() + MAPSIZE ||
924 ( sm_loc.z != get_levz() && !m.has_zlevels() ) ) {
925 continue;
926 }
927
928 add_msg( m_debug, "game::load_npcs: Spawning static NPC, %d:%d:%d (%d:%d:%d)",
929 get_levx(), get_levy(), get_levz(), sm_loc.x, sm_loc.y, sm_loc.z );
930 temp->place_on_map();
931 if( !m.inbounds( temp->pos() ) ) {
932 continue;
933 }
934 // In the rare case the npc was marked for death while
935 // it was on the overmap. Kill it.
936 if( temp->marked_for_death ) {
937 temp->die( nullptr );
938 } else {
939 active_npc.push_back( temp );
940 just_added.push_back( temp );
941 }
942 }
943
944 for( const auto &npc : just_added ) {
945 npc->on_load();
946 }
947
948 npcs_dirty = false;
949}
void on_load()
Retroactively update npc.
Definition: npc.cpp:2655
static constexpr int MAPSIZE

References active_npc, add_msg(), get_levx(), get_levy(), get_levz(), overmapbuffer::get_npcs_near_player(), HALF_MAPSIZE, map::has_zlevels(), map::inbounds(), m, m_debug, MAPSIZE, npcs_dirty, npc::on_load(), overmap_buffer, tripoint::x, tripoint::y, and tripoint::z.

Referenced by do_turn(), perhaps_add_random_npc(), place_player_overmap(), reload_npcs(), save_cyborg(), spawn_hallucination(), start_game(), and update_map().

◆ load_packs()

bool game::load_packs ( const std::string &  msg,
const std::vector< mod_id > &  packs,
loading_ui ui 
)

Load content packs.

Parameters
msgstring to display whilst loading prompt
packscontent packs to load in correct dependent order
uistructure for load progress display
Returns
true if all packs were found, false if any were missing

Definition at line 2981 of file game.cpp.

2982{
2983 ui.new_context( msg );
2984 std::vector<mod_id> missing;
2985 std::vector<mod_id> available;
2986
2987 for( const mod_id &e : packs ) {
2988 if( e.is_valid() ) {
2989 available.emplace_back( e );
2990 ui.add_entry( e->name() );
2991 } else {
2992 missing.push_back( e );
2993 }
2994 }
2995
2996 ui.show();
2997 for( const auto &e : available ) {
2998 const MOD_INFORMATION &mod = *e;
2999 load_data_from_dir( mod.path, mod.ident.str(), ui );
3000 ui.proceed();
3001 }
3002
3003 for( const auto &e : missing ) {
3004 debugmsg( "unknown content %s", e.c_str() );
3005 }
3006
3007 return missing.empty();
3008}

References available, string_id< T >::c_str(), debugmsg, string_id< T >::is_valid(), load_data_from_dir(), and MOD_INFORMATION::name().

Referenced by dump_stats().

◆ load_static_data()

void game::load_static_data ( )

Loads static data that does not depend on mods or similar.

Definition at line 324 of file game.cpp.

325{
326 // UI stuff, not mod-specific per definition
327 inp_mngr.init(); // Load input config JSON
328 // Init mappings for loading the json stuff
330 fullscreen = false;
331 was_fullscreen = false;
332 show_panel_adm = false;
334
335 // These functions do not load stuff from json.
336 // The content they load/initialize is hardcoded into the program.
337 // Therefore they can be loaded here.
338 // If this changes (if they load data from json), they have to
339 // be moved to game::load_mod or game::load_core_data
340
343}
bool was_fullscreen
Definition: game.h:1065
bool fullscreen
Definition: game.h:1064
void init()
Initializes the input manager, aka loads the input mapping configuration JSON.
Definition: input.cpp:111
void init()
Definition: panels.cpp:2309
void load_global()

References fullscreen, get_auto_pickup(), DynamicDataLoader::get_instance(), panel_manager::get_manager(), get_safemode(), input_manager::init(), panel_manager::init(), inp_mngr, auto_pickup::player_settings::load_global(), safemode::load_global(), show_panel_adm, and was_fullscreen.

◆ load_world_modfiles()

void game::load_world_modfiles ( loading_ui ui)

Loads core data and mods from the active world.

May throw.

Definition at line 2945 of file game.cpp.

2946{
2947 auto &mods = world_generator->active_world->active_mod_order;
2948
2949 // remove any duplicates whilst preserving order (fixes #19385)
2950 std::set<mod_id> found;
2951 mods.erase( std::remove_if( mods.begin(), mods.end(), [&found]( const mod_id & e ) {
2952 if( found.count( e ) ) {
2953 return true;
2954 } else {
2955 found.insert( e );
2956 return false;
2957 }
2958 } ), mods.end() );
2959
2960 // require at least one core mod (saves before version 6 may implicitly require dda pack)
2961 if( std::none_of( mods.begin(), mods.end(), []( const mod_id & e ) {
2962 return e->core;
2963} ) ) {
2964 mods.insert( mods.begin(), mod_id( "dda" ) );
2965 }
2966
2968 // this code does not care about mod dependencies,
2969 // it assumes that those dependencies are static and
2970 // are resolved during the creation of the world.
2971 // That means world->active_mod_order contains a list
2972 // of mods in the correct order.
2973 load_packs( _( "Loading files" ), mods, ui );
2974
2975 // Load additional mods from that world-specific folder
2976 load_data_from_dir( get_world_base_save_path() + "/mods", "custom", ui );
2977
2979}
void load_artifacts(const std::string &path)
Definition: artifact.cpp:1098
static const std::string SAVE_ARTIFACTS("artifacts.gsav")

References world_generator.

Referenced by setup().

◆ look_around() [1/2]

cata::optional< tripoint > game::look_around ( )

Definition at line 6860 of file game.cpp.

6861{
6863 look_around_result result = look_around( /*show_window=*/true, center, center, false, false,
6864 false );
6865 return result.position;
6866}

References center, look_around(), Character::pos(), u, and player::view_offset.

Referenced by handle_action(), list_monsters(), look_around(), peek(), and zones_manager().

◆ look_around() [2/2]

look_around_result game::look_around ( bool  show_window,
tripoint center,
const tripoint start_point,
bool  has_first_point,
bool  select_zone,
bool  peeking,
bool  is_moving_zone = false,
const tripoint end_point = tripoint_zero 
)
Parameters
show_windowdisplay the info window that holds the tile information in the position.
centerused to calculate the u.view_offset, could center the screen to the position it represents
start_pointthe start point of the targeting zone, also the initial local position of the cursor
has_first_pointshould be true if the first point has been selected when editing the zone
select_zonetrue if the zone is being edited
peekingdetermines if the player is peeking
is_moving_zonetrue if the zone is being moved, false by default
end_pointthe end point of the targeting zone, only used if is_moving_zone is true, default is tripoint_zero
Returns
look_around_result

Definition at line 6868 of file game.cpp.

6871{
6872 bVMonsterLookFire = false;
6873 // TODO: Make this `true`
6874 const bool allow_zlev_move = m.has_zlevels() && get_option<bool>( "FOV_3D" );
6875
6877
6878 tripoint lp = is_moving_zone ? ( start_point + end_point ) / 2 : start_point; // cursor
6879 int &lx = lp.x;
6880 int &ly = lp.y;
6881 int &lz = lp.z;
6882
6883 int soffset = get_option<int>( "FAST_SCROLL_OFFSET" );
6884 bool fast_scroll = false;
6885
6886 std::unique_ptr<ui_adaptor> ui;
6887 catacurses::window w_info;
6888 if( show_window ) {
6889 ui = std::make_unique<ui_adaptor>();
6890 ui->on_screen_resize( [&]( ui_adaptor & ui ) {
6891 int panel_width = panel_manager::get_manager().get_current_layout().begin()->get_width();
6893
6894 // If particularly small, base height on panel width irrespective of other elements.
6895 // Value here is attempting to get a square-ish result assuming 1x2 proportioned font.
6896 if( height < panel_width / 2 ) {
6897 height = panel_width / 2;
6898 }
6899
6900 int la_y = 0;
6901 int la_x = TERMX - panel_width;
6902 std::string position = get_option<std::string>( "LOOKAROUND_POSITION" );
6903 if( position == "left" ) {
6904 if( get_option<std::string>( "SIDEBAR_POSITION" ) == "right" ) {
6906 } else {
6907 la_x = panel_manager::get_manager().get_width_left() - panel_width;
6908 }
6909 }
6910 int la_h = height;
6911 int la_w = panel_width;
6912 w_info = catacurses::newwin( la_h, la_w, point( la_x, la_y ) );
6913
6914 ui.position_from_window( w_info );
6915 } );
6916 ui->mark_resize();
6917 }
6918
6919 std::string action;
6920 input_context ctxt( "LOOK" );
6921 ctxt.set_iso( true );
6922 ctxt.register_directions();
6923 ctxt.register_action( "COORDINATE" );
6924 ctxt.register_action( "LEVEL_UP" );
6925 ctxt.register_action( "LEVEL_DOWN" );
6926 ctxt.register_action( "TOGGLE_FAST_SCROLL" );
6927 ctxt.register_action( "EXTENDED_DESCRIPTION" );
6928 ctxt.register_action( "SELECT" );
6929 if( peeking ) {
6930 ctxt.register_action( "throw_blind" );
6931 }
6932 if( !select_zone ) {
6933 ctxt.register_action( "TRAVEL_TO" );
6934 ctxt.register_action( "LIST_ITEMS" );
6935 }
6936 ctxt.register_action( "MOUSE_MOVE" );
6937 ctxt.register_action( "CENTER" );
6938
6939 ctxt.register_action( "debug_scent" );
6940 ctxt.register_action( "debug_scent_type" );
6941 ctxt.register_action( "debug_temp" );
6942 ctxt.register_action( "debug_visibility" );
6943 ctxt.register_action( "debug_lighting" );
6944 ctxt.register_action( "debug_radiation" );
6945 ctxt.register_action( "debug_submap_grid" );
6946 ctxt.register_action( "debug_hour_timer" );
6947 ctxt.register_action( "CONFIRM" );
6948 ctxt.register_action( "QUIT" );
6949 ctxt.register_action( "HELP_KEYBINDINGS" );
6950 if( use_tiles ) {
6951 ctxt.register_action( "zoom_out" );
6952 ctxt.register_action( "zoom_in" );
6953 }
6954#if defined(TILES)
6955 ctxt.register_action( "toggle_pixel_minimap" );
6956#endif // TILES
6957
6958 const int old_levz = get_levz();
6959 const int min_levz = std::max( old_levz - fov_3d_z_range, -OVERMAP_DEPTH );
6960 const int max_levz = std::min( old_levz + fov_3d_z_range, OVERMAP_HEIGHT );
6961
6962 m.update_visibility_cache( old_levz );
6964
6965 bool blink = true;
6967
6968 shared_ptr_fast<draw_callback_t> ter_indicator_cb;
6969
6970 if( show_window && ui ) {
6971 ui->on_redraw( [&]( const ui_adaptor & ) {
6972 werase( w_info );
6973 draw_border( w_info );
6974
6975 center_print( w_info, 0, c_white, string_format( _( "< <color_green>Look Around</color> >" ) ) );
6976
6977 std::string extended_descr_text = string_format( _( "%s - %s" ),
6978 ctxt.get_desc( "EXTENDED_DESCRIPTION" ),
6979 ctxt.get_action_name( "EXTENDED_DESCRIPTION" ) );
6980 std::string fast_scroll_text = string_format( _( "%s - %s" ),
6981 ctxt.get_desc( "TOGGLE_FAST_SCROLL" ),
6982 ctxt.get_action_name( "TOGGLE_FAST_SCROLL" ) );
6983#if defined(TILES)
6984 std::string pixel_minimap_text = string_format( _( "%s - %s" ),
6985 ctxt.get_desc( "toggle_pixel_minimap" ),
6986 ctxt.get_action_name( "toggle_pixel_minimap" ) );
6987#endif // TILES
6988
6989 center_print( w_info, getmaxy( w_info ) - 2, c_light_gray, extended_descr_text );
6990 mvwprintz( w_info, point( 1, getmaxy( w_info ) - 1 ), fast_scroll ? c_light_green : c_green,
6991 fast_scroll_text );
6992#if defined(TILES)
6993 right_print( w_info, getmaxy( w_info ) - 1, 1, pixel_minimap_option ? c_light_green : c_green,
6994 pixel_minimap_text );
6995#endif // TILES
6996
6997 int first_line = 1;
6998 const int last_line = getmaxy( w_info ) - 3;
6999 pre_print_all_tile_info( lp, w_info, first_line, last_line, cache );
7000
7001 wnoutrefresh( w_info );
7002 } );
7003 ter_indicator_cb = make_shared_fast<draw_callback_t>( [&]() {
7004 draw_look_around_cursor( lp, cache );
7005 } );
7006 add_draw_callback( ter_indicator_cb );
7007 }
7008
7009 cata::optional<tripoint> zone_start;
7010 cata::optional<tripoint> zone_end;
7011 bool zone_blink = false;
7012 bool zone_cursor = true;
7013 shared_ptr_fast<draw_callback_t> zone_cb = create_zone_callback( zone_start, zone_end, zone_blink,
7014 zone_cursor, is_moving_zone );
7015 add_draw_callback( zone_cb );
7016
7017 is_looking = true;
7018 const tripoint prev_offset = u.view_offset;
7019#if defined(TILES)
7020 const int prev_tileset_zoom = tileset_zoom;
7021 while( is_moving_zone && square_dist( start_point, end_point ) > 256 / get_zoom() &&
7022 get_zoom() != 4 ) {
7023 zoom_out();
7024 }
7026#endif
7027 do {
7028 u.view_offset = center - u.pos();
7029 if( select_zone ) {
7030 if( has_first_point ) {
7031 zone_start = start_point;
7032 zone_end = lp;
7033 } else {
7034 zone_start = lp;
7035 zone_end = cata::nullopt;
7036 }
7037 // Actually accessed from the terrain overlay callback `zone_cb` in the
7038 // call to `ui_manager::redraw`.
7039 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
7040 zone_blink = blink;
7041 }
7042
7043 if( is_moving_zone ) {
7044 zone_start = lp - ( start_point + end_point ) / 2 + start_point;
7045 zone_end = lp - ( start_point + end_point ) / 2 + end_point;
7046 // Actually accessed from the terrain overlay callback `zone_cb` in the
7047 // call to `ui_manager::redraw`.
7048 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
7049 zone_blink = blink;
7050 }
7053 if( ( select_zone && has_first_point ) || is_moving_zone ) {
7054 ctxt.set_timeout( BLINK_SPEED );
7055 }
7056
7057 //Wait for input
7058 // only specify a timeout here if "EDGE_SCROLL" is enabled
7059 // otherwise use the previously set timeout
7060 const tripoint edge_scroll = mouse_edge_scrolling_terrain( ctxt );
7061 const int scroll_timeout = get_option<int>( "EDGE_SCROLL" );
7062 const bool edge_scrolling = edge_scroll != tripoint_zero && scroll_timeout >= 0;
7063 if( edge_scrolling ) {
7064 action = ctxt.handle_input( scroll_timeout );
7065 } else {
7066 action = ctxt.handle_input();
7067 }
7068 if( ( action == "LEVEL_UP" || action == "LEVEL_DOWN" || action == "MOUSE_MOVE" ||
7069 ctxt.get_direction( action ) ) && ( ( select_zone && has_first_point ) || is_moving_zone ) ) {
7070 blink = true; // Always draw blink symbols when moving cursor
7071 } else if( action == "TIMEOUT" ) {
7072 blink = !blink;
7073 }
7074 if( action == "LIST_ITEMS" ) {
7076 } else if( action == "TOGGLE_FAST_SCROLL" ) {
7077 fast_scroll = !fast_scroll;
7078 } else if( action == "toggle_pixel_minimap" ) {
7080
7081 if( show_window && ui ) {
7082 ui->mark_resize();
7083 }
7084 } else if( action == "LEVEL_UP" || action == "LEVEL_DOWN" ) {
7085 if( !allow_zlev_move ) {
7086 continue;
7087 }
7088
7089 const int dz = ( action == "LEVEL_UP" ? 1 : -1 );
7090 lz = clamp( lz + dz, min_levz, max_levz );
7091 center.z = clamp( center.z + dz, min_levz, max_levz );
7092
7093 add_msg( m_debug, "levx: %d, levy: %d, levz: %d", get_levx(), get_levy(), center.z );
7094 u.view_offset.z = center.z - u.posz();
7096 } else if( action == "TRAVEL_TO" ) {
7097 if( !u.sees( lp ) ) {
7098 add_msg( _( "You can't see that destination." ) );
7099 continue;
7100 }
7101
7102 auto route = m.route( u.pos(), lp, u.get_pathfinding_settings(), u.get_path_avoid() );
7103 if( route.size() > 1 ) {
7104 route.pop_back();
7105 u.set_destination( route );
7106 } else {
7107 add_msg( m_info, _( "You can't travel there." ) );
7108 continue;
7109 }
7110 } else if( action == "debug_scent" || action == "debug_scent_type" ) {
7112 display_scent();
7113 }
7114 } else if( action == "debug_temp" ) {
7117 }
7118 } else if( action == "debug_lighting" ) {
7121 }
7122 } else if( action == "debug_transparency" ) {
7125 }
7126 } else if( action == "debug_radiation" ) {
7129 }
7130 } else if( action == "debug_submap_grid" ) {
7131 g->debug_submap_grid_overlay = !g->debug_submap_grid_overlay;
7132 } else if( action == "debug_hour_timer" ) {
7134 } else if( action == "EXTENDED_DESCRIPTION" ) {
7136 } else if( action == "CENTER" ) {
7137 center = u.pos();
7138 lp = u.pos();
7139 u.view_offset.z = 0;
7140 } else if( action == "MOUSE_MOVE" || action == "TIMEOUT" ) {
7141 // This block is structured this way so that edge scroll can work
7142 // whether the mouse is moving at the edge or simply stationary
7143 // at the edge. But even if edge scroll isn't in play, there's
7144 // other things for us to do here.
7145
7146 if( edge_scrolling ) {
7147 center += action == "MOUSE_MOVE" ? edge_scroll * 2 : edge_scroll;
7148 } else if( action == "MOUSE_MOVE" ) {
7149 const cata::optional<tripoint> mouse_pos = ctxt.get_coordinates( w_terrain );
7150 if( mouse_pos ) {
7151 lx = mouse_pos->x;
7152 ly = mouse_pos->y;
7153 }
7154 }
7155 } else if( cata::optional<tripoint> vec = ctxt.get_direction( action ) ) {
7156 if( fast_scroll ) {
7157 vec->x *= soffset;
7158 vec->y *= soffset;
7159 }
7160
7161 lx = lx + vec->x;
7162 ly = ly + vec->y;
7163 center.x = center.x + vec->x;
7164 center.y = center.y + vec->y;
7165 } else if( action == "throw_blind" ) {
7166 result.peek_action = PA_BLIND_THROW;
7167 } else if( action == "zoom_in" ) {
7168 center.x = lp.x;
7169 center.y = lp.y;
7170 zoom_in();
7172 } else if( action == "zoom_out" ) {
7173 center.x = lp.x;
7174 center.y = lp.y;
7175 zoom_out();
7177 }
7178 } while( action != "QUIT" && action != "CONFIRM" && action != "SELECT" && action != "TRAVEL_TO" &&
7179 action != "throw_blind" );
7180
7181 if( m.has_zlevels() && center.z != old_levz ) {
7182 m.invalidate_map_cache( old_levz );
7183 m.build_map_cache( old_levz );
7184 u.view_offset.z = 0;
7185 }
7186
7187 ctxt.reset_timeout();
7188 u.view_offset = prev_offset;
7189 zone_cb = nullptr;
7190 is_looking = false;
7191
7193 bVMonsterLookFire = true;
7194
7195 if( action == "CONFIRM" || action == "SELECT" ) {
7196 result.position = is_moving_zone ? zone_start : lp;
7197 }
7198
7199#if defined(TILES)
7200 if( is_moving_zone && get_zoom() != prev_tileset_zoom ) {
7201 // Reset the tileset zoom to the previous value
7202 set_zoom( prev_tileset_zoom );
7204 }
7205#endif
7206
7207 return result;
7208}
int fov_3d_z_range
3D FoV range, in Z levels, in both directions.
bool pixel_minimap_option
Whether to show the pixel minimap.
tripoint mouse_edge_scrolling_terrain(input_context &ctxt)
Used to implement mouse "edge scrolling".
Definition: game.cpp:2407
void set_zoom(int level)
Definition: game.cpp:7359
void draw_look_around_cursor(const tripoint &lp, const visibility_variables &cache)
Definition: game.cpp:5973
void extended_description(const tripoint &p)
Long description of (visible) things at tile.
void pre_print_all_tile_info(const tripoint &lp, const catacurses::window &w_info, int &line, int last_line, const visibility_variables &cache)
Definition: game.cpp:6847
int get_zoom() const
Definition: game.cpp:7371
const visibility_variables & get_visibility_variables_cache() const
Definition: map.cpp:5627
void invalidate_map_cache(const int zlev)
Definition: map.h:471
std::vector< window_panel > & get_current_layout()
Definition: panels.cpp:2277
int square_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:505
static shared_ptr_fast< game::draw_callback_t > create_zone_callback(const cata::optional< tripoint > &zone_start, const cata::optional< tripoint > &zone_end, const bool &zone_blink, const bool &zone_cursor, const bool &is_moving_zone=false)
Definition: game.cpp:3402
@ PA_BLIND_THROW
Definition: game.h:122
static constexpr int OVERMAP_HEIGHT
static constexpr int BLINK_SPEED
static constexpr int OVERMAP_DEPTH
int right_print(const catacurses::window &w, const int line, const int right_indent, const nc_color &FG, const std::string &text)
Definition: output.cpp:461

References _, action, add_draw_callback(), add_msg(), BLINK_SPEED, map::build_map_cache(), bVMonsterLookFire, c_green, c_light_gray, c_light_green, c_white, center, center_print(), clamp(), create_zone_callback(), display_lighting(), display_radiation(), display_scent(), display_temperature(), display_transparency(), draw_border(), draw_look_around_cursor(), extended_description(), fov_3d_z_range, g, input_context::get_action_name(), input_context::get_coordinates(), panel_manager::get_current_layout(), input_context::get_desc(), input_context::get_direction(), get_levx(), get_levy(), get_levz(), panel_manager::get_manager(), Character::get_path_avoid(), Character::get_pathfinding_settings(), map::get_visibility_variables_cache(), panel_manager::get_width_left(), get_zoom(), catacurses::getmaxy(), input_context::handle_input(), map::has_zlevels(), invalidate_main_ui_adaptor(), map::invalidate_map_cache(), is_looking, MAP_SHARING::isCompetitive(), MAP_SHARING::isDebugger(), list_items_monsters(), m, m_debug, m_info, mark_main_ui_adaptor_resize(), mouse_edge_scrolling_terrain(), mvwprintz(), catacurses::newwin(), cata::nullopt, OVERMAP_DEPTH, OVERMAP_HEIGHT, PA_BLIND_THROW, pixel_minimap_option, Character::pos(), Character::posz(), pre_print_all_tile_info(), ui_manager::redraw(), reenter_fullscreen(), input_context::register_action(), input_context::register_directions(), input_context::reset_timeout(), right_print(), map::route(), Character::sees(), Character::set_destination(), input_context::set_iso(), input_context::set_timeout(), set_zoom(), square_dist(), string_format(), temp_exit_fullscreen(), TERMX, TERMY, tileset_zoom, toggle_debug_hour_timer(), toggle_pixel_minimap(), tripoint_zero, u, map::update_visibility_cache(), use_tiles, player::view_offset, w_pixel_minimap, w_terrain, catacurses::werase(), catacurses::wnoutrefresh(), tripoint::x, tripoint::y, tripoint::z, zoom_in(), and zoom_out().

◆ look_debug()

cata::optional< tripoint > game::look_debug ( )

Definition at line 5966 of file game.cpp.

5967{
5968 editmap edit;
5969 return edit.edit();
5970}
cata::optional< tripoint > edit()
Definition: editmap.cpp:339

References editmap::edit().

◆ mark_main_ui_adaptor_resize()

void game::mark_main_ui_adaptor_resize ( ) const

Definition at line 3359 of file game.cpp.

3360{
3362 if( ui ) {
3363 ui->mark_resize();
3364 }
3365}

References main_ui_adaptor.

Referenced by handle_action(), look_around(), toggle_fullscreen(), and toggle_pixel_minimap().

◆ memorial()

memorial_logger & game::memorial ( )

Definition at line 3101 of file game.cpp.

3102{
3103 return *memorial_logger_ptr;
3104}

References memorial_logger_ptr.

Referenced by cleanup_at_end(), load(), save_player_data(), win(), win_screen(), and write_memorial_file().

◆ mon_info()

void game::mon_info ( const catacurses::window w,
int  hor_padding = 0 
)

Definition at line 4050 of file game.cpp.

4051{
4052 const monster_visible_info &mon_visible = u.get_mon_visible();
4053 const auto &unique_types = mon_visible.unique_types;
4054 const auto &unique_mons = mon_visible.unique_mons;
4055 const auto &dangerous = mon_visible.dangerous;
4056
4057 const int width = getmaxx( w ) - 2 * hor_padding;
4058 const int maxheight = getmaxy( w );
4059
4060 const int startrow = 0;
4061
4062 // Print the direction headings
4063 // Reminder:
4064 // 7 0 1 unique_types uses these indices;
4065 // 6 8 2 0-7 are provide by direction_from()
4066 // 5 4 3 8 is used for local monsters (for when we explain them below)
4067
4068 const std::array<std::string, 8> dir_labels = {{
4069 _( "North:" ), _( "NE:" ), _( "East:" ), _( "SE:" ),
4070 _( "South:" ), _( "SW:" ), _( "West:" ), _( "NW:" )
4071 }
4072 };
4073 std::array<int, 8> widths;
4074 for( int i = 0; i < 8; i++ ) {
4075 widths[i] = utf8_width( dir_labels[i] );
4076 }
4077 std::array<int, 8> xcoords;
4078 const std::array<int, 8> ycoords = {{ 0, 0, 1, 2, 2, 2, 1, 0 }};
4079 xcoords[0] = xcoords[4] = width / 3;
4080 xcoords[1] = xcoords[3] = xcoords[2] = ( width / 3 ) * 2;
4081 xcoords[5] = xcoords[6] = xcoords[7] = 0;
4082 //for the alignment of the 1,2,3 rows on the right edge
4083 xcoords[2] -= utf8_width( _( "East:" ) ) - utf8_width( _( "NE:" ) );
4084 for( int i = 0; i < 8; i++ ) {
4085 nc_color c = unique_types[i].empty() && unique_mons[i].empty() ? c_dark_gray
4086 : ( dangerous[i] ? c_light_red : c_light_gray );
4087 mvwprintz( w, point( xcoords[i] + hor_padding, ycoords[i] + startrow ), c, dir_labels[i] );
4088 }
4089
4090 // Print the symbols of all monsters in all directions.
4091 for( int i = 0; i < 8; i++ ) {
4092 point pr( xcoords[i] + widths[i] + 1, ycoords[i] + startrow );
4093
4094 // The list of symbols needs a space on each end.
4095 int symroom = ( width / 3 ) - widths[i] - 2;
4096 const int typeshere_npc = unique_types[i].size();
4097 const int typeshere_mon = unique_mons[i].size();
4098 const int typeshere = typeshere_mon + typeshere_npc;
4099 for( int j = 0; j < typeshere && j < symroom; j++ ) {
4100 nc_color c;
4101 std::string sym;
4102 if( symroom < typeshere && j == symroom - 1 ) {
4103 // We've run out of room!
4104 c = c_white;
4105 sym = "+";
4106 } else if( j < typeshere_npc ) {
4107 switch( unique_types[i][j]->get_attitude() ) {
4108 case NPCATT_KILL:
4109 c = c_red;
4110 break;
4111 case NPCATT_FOLLOW:
4112 c = c_light_green;
4113 break;
4114 default:
4115 c = c_pink;
4116 break;
4117 }
4118 sym = "@";
4119 } else {
4120 const mtype &mt = *unique_mons[i][j - typeshere_npc];
4121 c = mt.color;
4122 sym = mt.sym;
4123 }
4124 mvwprintz( w, pr, c, sym );
4125
4126 pr.x++;
4127 }
4128 }
4129
4130 // Now we print their full names!
4131
4132 std::set<const mtype *> listed_mons;
4133
4134 // Start printing monster names on row 4. Rows 0-2 are for labels, and row 3
4135 // is blank.
4136 point pr( hor_padding, 4 + startrow );
4137
4138 // Print monster names, starting with those at location 8 (nearby).
4139 for( int j = 8; j >= 0 && pr.y < maxheight; j-- ) {
4140 // Separate names by some number of spaces (more for local monsters).
4141 int namesep = ( j == 8 ? 2 : 1 );
4142 for( const mtype *type : unique_mons[j] ) {
4143 if( pr.y >= maxheight ) {
4144 // no space to print to anyway
4145 break;
4146 }
4147 if( listed_mons.count( type ) > 0 ) {
4148 // this type is already printed.
4149 continue;
4150 }
4151 listed_mons.insert( type );
4152
4153 const mtype &mt = *type;
4154 const std::string name = mt.nname();
4155
4156 // Move to the next row if necessary. (The +2 is for the "Z ").
4157 if( pr.x + 2 + utf8_width( name ) >= width ) {
4158 pr.y++;
4159 pr.x = hor_padding;
4160 }
4161
4162 if( pr.y < maxheight ) { // Don't print if we've overflowed
4163 mvwprintz( w, pr, mt.color, mt.sym );
4164 pr.x += 2; // symbol and space
4165 nc_color danger = c_dark_gray;
4166 if( mt.difficulty >= 30 ) {
4167 danger = c_red;
4168 } else if( mt.difficulty >= 16 ) {
4169 danger = c_light_red;
4170 } else if( mt.difficulty >= 8 ) {
4171 danger = c_white;
4172 } else if( mt.agro > 0 ) {
4173 danger = c_light_gray;
4174 }
4175 mvwprintz( w, pr, danger, name );
4176 pr.x += utf8_width( name ) + namesep;
4177 }
4178 }
4179 }
4180}
@ NPCATT_KILL
Definition: npc.h:91
@ NPCATT_FOLLOW
Definition: npc.h:84
std::vector< const mtype * > unique_mons[9]
Definition: avatar.h:47
bool dangerous[8]
Definition: avatar.h:50
std::vector< npc * > unique_types[9]
Definition: avatar.h:46
Definition: mtype.h:208
std::string sym
UTF-8 encoded symbol, should be exactly one cell wide.
Definition: mtype.h:253
nc_color color
Definition: mtype.h:258
int difficulty
Definition: mtype.h:264
int agro
e.g.
Definition: mtype.h:269

References _, mtype::agro, c, c_dark_gray, c_light_gray, c_light_green, c_light_red, c_pink, c_red, c_white, mtype::color, monster_visible_info::dangerous, mtype::difficulty, avatar::get_mon_visible(), catacurses::getmaxx(), catacurses::getmaxy(), mvwprintz(), om_direction::name(), mtype::nname(), NPCATT_FOLLOW, NPCATT_KILL, mtype::sym, type, u, monster_visible_info::unique_mons, monster_visible_info::unique_types, utf8_width(), point::x, and point::y.

◆ mon_info_update()

void game::mon_info_update ( )

Definition at line 4182 of file game.cpp.

4183{
4184 int newseen = 0;
4185 const int safe_proxy_dist = get_option<int>( "SAFEMODEPROXIMITY" );
4186 const int iProxyDist = ( safe_proxy_dist <= 0 ) ? MAX_VIEW_DISTANCE :
4187 safe_proxy_dist;
4188
4189 monster_visible_info &mon_visible = u.get_mon_visible();
4190 auto &new_seen_mon = mon_visible.new_seen_mon;
4191 auto &unique_types = mon_visible.unique_types;
4192 auto &unique_mons = mon_visible.unique_mons;
4193 auto &dangerous = mon_visible.dangerous;
4194
4195 // 7 0 1 unique_types uses these indices;
4196 // 6 8 2 0-7 are provide by direction_from()
4197 // 5 4 3 8 is used for local monsters (for when we explain them below)
4198 for( auto &t : unique_types ) {
4199 t.clear();
4200 }
4201 for( auto &m : unique_mons ) {
4202 m.clear();
4203 }
4204 std::fill( dangerous, dangerous + 8, false );
4205
4206 const tripoint view = u.pos() + u.view_offset;
4207 new_seen_mon.clear();
4208
4209 // TODO: no reason to have it static here
4210 static time_point previous_turn = calendar::start_of_cataclysm;
4211 const time_duration sm_ignored_time = time_duration::from_turns(
4212 get_option<int>( "SAFEMODEIGNORETURNS" ) );
4213
4215 monster *m = dynamic_cast<monster *>( c );
4216 npc *p = dynamic_cast<npc *>( c );
4217 const direction dir_to_mon = direction_from( view.xy(), point( c->posx(), c->posy() ) );
4218 const int mx = POSX + ( c->posx() - view.x );
4219 const int my = POSY + ( c->posy() - view.y );
4220 int index = 8;
4221 if( !is_valid_in_w_terrain( point( mx, my ) ) ) {
4222 // for compatibility with old code, see diagram below, it explains the values for index,
4223 // also might need revisiting one z-levels are in.
4224 switch( dir_to_mon ) {
4228 index = 7;
4229 break;
4231 case direction::NORTH:
4233 index = 0;
4234 break;
4238 index = 1;
4239 break;
4241 case direction::WEST:
4243 index = 6;
4244 break;
4246 case direction::CENTER:
4248 index = 8;
4249 break;
4251 case direction::EAST:
4253 index = 2;
4254 break;
4258 index = 5;
4259 break;
4261 case direction::SOUTH:
4263 index = 4;
4264 break;
4268 index = 3;
4269 break;
4270 }
4271 }
4272
4273 rule_state safemode_state = RULE_NONE;
4274 const bool safemode_empty = get_safemode().empty();
4275
4276 if( m != nullptr ) {
4277 //Safemode monster check
4278 monster &critter = *m;
4279
4280 const monster_attitude matt = critter.attitude( &u );
4281 const int mon_dist = rl_dist( u.pos(), critter.pos() );
4282 safemode_state = get_safemode().check_monster( critter.name(), critter.attitude_to( u ), mon_dist );
4283
4284 if( ( !safemode_empty && safemode_state == RULE_BLACKLISTED ) || ( safemode_empty &&
4285 ( MATT_ATTACK == matt || MATT_FOLLOW == matt ) ) ) {
4286 if( index < 8 && critter.sees( g->u ) ) {
4287 dangerous[index] = true;
4288 }
4289
4290 if( !safemode_empty || mon_dist <= iProxyDist ) {
4291 bool passmon = false;
4292 if( critter.ignoring > 0 ) {
4293 if( safe_mode != SAFE_MODE_ON ) {
4294 critter.ignoring = 0;
4295 } else if( ( sm_ignored_time == 0_seconds || ( critter.lastseen_turn &&
4296 *critter.lastseen_turn > calendar::turn - sm_ignored_time ) ) &&
4297 ( mon_dist > critter.ignoring / 2 || mon_dist < 6 ) ) {
4298 passmon = true;
4299 }
4300 critter.lastseen_turn = calendar::turn;
4301 }
4302
4303 if( !passmon ) {
4304 newseen++;
4305 new_seen_mon.push_back( shared_from( critter ) );
4306 }
4307 }
4308 }
4309
4310 std::vector<const mtype *> &vec = unique_mons[index];
4311 if( std::find( vec.begin(), vec.end(), critter.type ) == vec.end() ) {
4312 vec.push_back( critter.type );
4313 }
4314 } else if( p != nullptr ) {
4315 //Safe mode NPC check
4316
4317 const int npc_dist = rl_dist( u.pos(), p->pos() );
4318 safemode_state = get_safemode().check_monster( get_safemode().npc_type_name(), p->attitude_to( u ),
4319 npc_dist );
4320
4321 if( ( !safemode_empty && safemode_state == RULE_BLACKLISTED ) || ( safemode_empty &&
4322 p->get_attitude() == NPCATT_KILL ) ) {
4323 if( !safemode_empty || npc_dist <= iProxyDist ) {
4324 newseen++;
4325 }
4326 }
4327 unique_types[index].push_back( p );
4328 }
4329 }
4330
4331 if( newseen > mostseen ) {
4332 if( newseen - mostseen == 1 ) {
4333 if( !new_seen_mon.empty() ) {
4334 monster &critter = *new_seen_mon.back();
4336 string_format( _( "%s spotted!" ), critter.name() ) );
4337 if( u.has_trait( trait_id( "M_DEFENDER" ) ) && critter.type->in_species( PLANT ) ) {
4338 add_msg( m_warning, _( "We have detected a %s - an enemy of the Mycus!" ), critter.name() );
4340 u.add_effect( effect_adrenaline_mycus, 30_minutes );
4341 } else if( u.get_effect_int( effect_adrenaline_mycus ) == 1 ) {
4342 // Triffids present. We ain't got TIME to adrenaline comedown!
4343 u.add_effect( effect_adrenaline_mycus, 15_minutes );
4344 u.mod_pain( 3 ); // Does take it out of you, though
4345 add_msg( m_info, _( "Our fibers strain with renewed wrath!" ) );
4346 }
4347 }
4348 } else {
4349 //Hostile NPC
4351 _( "Hostile survivor spotted!" ) );
4352 }
4353 } else {
4355 }
4357 if( safe_mode == SAFE_MODE_ON ) {
4359 }
4360 } else if( calendar::turn > previous_turn && get_option<bool>( "AUTOSAFEMODE" ) &&
4361 newseen == 0 ) { // Auto-safe mode, but only if it's a new turn
4362 turnssincelastmon += to_turns<int>( calendar::turn - previous_turn );
4363 if( turnssincelastmon >= get_option<int>( "AUTOSAFEMODETURNS" ) && safe_mode == SAFE_MODE_OFF ) {
4365 add_msg( m_info, _( "Safe mode ON!" ) );
4366 }
4367 }
4368
4369 if( newseen == 0 && safe_mode == SAFE_MODE_STOP ) {
4371 }
4372
4373 previous_turn = calendar::turn;
4374 mostseen = newseen;
4375}
int get_effect_int(const efftype_id &eff_id, body_part bp=num_bp) const
Returns the intensity of the matching effect.
Definition: creature.cpp:1250
virtual bool sees(const Creature &critter) const
The functions check whether this creature can see the target.
Definition: creature.cpp:202
bool cancel_activity_or_ignore_query(distraction_type type, const std::string &text)
Asks if the player wants to cancel their activity and if so cancels it.
Definition: game.cpp:1792
monster_attitude attitude(const Character *u=nullptr) const
Definition: monster.cpp:1066
cata::optional< time_point > lastseen_turn
Definition: monster.h:508
Attitude attitude_to(const Creature &other) const override
Attitude (of this creature) towards another creature.
Definition: npc.cpp:2074
rule_state check_monster(const std::string &creature_name_in, Creature::Attitude attitude_in, int proximity_in) const
bool empty() const
rule_state
Definition: enums.h:51
@ RULE_NONE
Definition: enums.h:52
bool is_valid_in_w_terrain(const point &p)
Definition: game.cpp:274
static const species_id PLANT("PLANT")
static const efftype_id effect_adrenaline_mycus("adrenaline_mycus")
static constexpr int MAPSIZE_X
monster_attitude
Definition: monster.h:54
@ MATT_FOLLOW
Definition: monster.h:60
@ MATT_ATTACK
Definition: monster.h:61
FMT_NOINLINE OutputIt fill(OutputIt it, size_t n, const fill_t< Char > &fill)
bool in_species(const species_id &spec) const
Definition: mtype.cpp:122

References _, ABOVECENTER, ABOVEEAST, ABOVENORTH, ABOVENORTHEAST, ABOVENORTHWEST, ABOVESOUTH, ABOVESOUTHEAST, ABOVESOUTHWEST, ABOVEWEST, Creature::add_effect(), add_msg(), monster::attitude(), monster::attitude_to(), npc::attitude_to(), BELOWCENTER, BELOWEAST, BELOWNORTH, BELOWNORTHEAST, BELOWNORTHWEST, BELOWSOUTH, BELOWSOUTHEAST, BELOWSOUTHWEST, BELOWWEST, c, cancel_activity_or_ignore_query(), CENTER, safemode::check_monster(), monster_visible_info::dangerous, direction_from(), EAST, effect_adrenaline_mycus, safemode::empty(), detail::fill(), detail::find(), time_duration::from_turns(), g, npc::get_attitude(), Creature::get_effect_int(), avatar::get_mon_visible(), get_safemode(), Character::get_visible_creatures(), Creature::has_effect(), Character::has_trait(), hostile_spotted_far, monster::ignoring, mtype::in_species(), is_valid_in_w_terrain(), monster::lastseen_turn, m, m_info, m_warning, MAPSIZE_X, MATT_ATTACK, MATT_FOLLOW, MAX_VIEW_DISTANCE, player::mod_pain(), mostseen, monster::name(), monster_visible_info::new_seen_mon, NORTH, NORTHEAST, NORTHWEST, NPCATT_KILL, PLANT, Character::pos(), monster::pos(), POSX, POSY, rl_dist(), RULE_BLACKLISTED, RULE_NONE, safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, SAFE_MODE_STOP, Creature::sees(), set_safe_mode(), shared_from(), SOUTH, SOUTHEAST, SOUTHWEST, calendar::start_of_cataclysm, string_format(), calendar::turn, turnssincelastmon, monster::type, u, monster_visible_info::unique_mons, monster_visible_info::unique_types, player::view_offset, WEST, tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by do_turn().

◆ monmove()

void game::monmove ( )
private

Definition at line 4412 of file game.cpp.

4413{
4414 cleanup_dead();
4415
4416 for( monster &critter : all_monsters() ) {
4417 // Critters in impassable tiles get pushed away, unless it's not impassable for them
4418 if( !critter.is_dead() && m.impassable( critter.pos() ) && !critter.can_move_to( critter.pos() ) ) {
4419 std::string msg = string_format( "%s can't move to its location! %s %s", critter.name(),
4420 critter.pos().to_string(), m.tername( critter.pos() ) );
4421 dbg( DL::Error ) << msg;
4422 add_msg( m_debug, msg );
4423 bool okay = false;
4424 for( const tripoint &dest : m.points_in_radius( critter.pos(), 3 ) ) {
4425 if( critter.can_move_to( dest ) && is_empty( dest ) ) {
4426 critter.setpos( dest );
4427 okay = true;
4428 break;
4429 }
4430 }
4431 if( !okay ) {
4432 // die of "natural" cause (overpopulation is natural)
4433 critter.die( nullptr );
4434 }
4435 }
4436
4437 if( !critter.is_dead() ) {
4438 critter.process_items();
4439 }
4440
4441 if( !critter.is_dead() ) {
4442 critter.process_turn();
4443 }
4444
4445 m.creature_in_field( critter );
4446 if( calendar::once_every( 1_days ) ) {
4447 if( critter.has_flag( MF_MILKABLE ) ) {
4448 critter.refill_udders();
4449 }
4450 critter.try_reproduce();
4451 }
4452 while( critter.moves > 0 && !critter.is_dead() && !critter.has_effect( effect_ridden ) ) {
4453 critter.made_footstep = false;
4454 // Controlled critters don't make their own plans
4455 if( !critter.has_effect( effect_ai_controlled ) ) {
4456 // Formulate a path to follow
4457 critter.plan();
4458 }
4459 critter.move(); // Move one square, possibly hit u
4460 critter.process_triggers();
4461 m.creature_in_field( critter );
4462 }
4463
4464 if( !critter.is_dead() &&
4465 u.has_active_bionic( bionic_id( "bio_alarm" ) ) &&
4466 u.get_power_level() >= 25_kJ &&
4467 rl_dist( u.pos(), critter.pos() ) <= 5 &&
4468 !critter.is_hallucination() ) {
4469 u.mod_power_level( -25_kJ );
4470 add_msg( m_warning, _( "Your motion alarm goes off!" ) );
4472 _( "Your motion alarm goes off!" ) );
4473 if( u.has_effect( efftype_id( "sleep" ) ) ) {
4474 u.wake_up();
4475 }
4476 }
4477 }
4478
4479 cleanup_dead();
4480
4481 // The remaining monsters are all alive, but may be outside of the reality bubble.
4482 // If so, despawn them. This is not the same as dying, they will be stored for later and the
4483 // monster::die function is not called.
4484 for( monster &critter : all_monsters() ) {
4485 if( critter.posx() < 0 - ( MAPSIZE_X ) / 6 ||
4486 critter.posy() < 0 - ( MAPSIZE_Y ) / 6 ||
4487 critter.posx() > ( MAPSIZE_X * 7 ) / 6 ||
4488 critter.posy() > ( MAPSIZE_Y * 7 ) / 6 ) {
4489 despawn_monster( critter );
4490 }
4491 }
4492
4493 // Now, do active NPCs.
4494 for( npc &guy : g->all_npcs() ) {
4495 int turns = 0;
4496 if( guy.is_mounted() ) {
4497 guy.check_mount_is_spooked();
4498 }
4499 m.creature_in_field( guy );
4500 if( !guy.has_effect( effect_npc_suspend ) ) {
4501 guy.process_turn();
4502 }
4503 while( !guy.is_dead() && guy.moves > 0 && turns < 10 &&
4504 ( !guy.in_sleep_state() || guy.activity.id() == ACT_OPERATION )
4505 ) {
4506 int moves = guy.moves;
4507 guy.move();
4508 if( moves == guy.moves ) {
4509 // Count every time we exit npc::move() without spending any moves.
4510 turns++;
4511 }
4512
4513 // Turn on debug mode when in infinite loop
4514 // It has to be done before the last turn, otherwise
4515 // there will be no meaningful debug output.
4516 if( turns == 9 ) {
4517 debugmsg( "NPC %s entered infinite loop. Turning on debug mode",
4518 guy.name );
4519 debug_mode = true;
4520 }
4521 }
4522
4523 // If we spun too long trying to decide what to do (without spending moves),
4524 // Invoke cognitive suspension to prevent an infinite loop.
4525 if( turns == 10 ) {
4526 add_msg( _( "%s faints!" ), guy.name );
4527 guy.reboot();
4528 }
4529
4530 if( !guy.is_dead() ) {
4531 guy.npc_update_body();
4532 }
4533 }
4534 cleanup_dead();
4535}
void mod_power_level(const units::energy &npower)
Definition: character.cpp:1990
units::energy get_power_level() const
Definition: character.cpp:1970
void wake_up()
Definition: avatar.cpp:950
static const activity_id ACT_OPERATION("ACT_OPERATION")
static const efftype_id effect_npc_suspend("npc_suspend")
static const efftype_id effect_ai_controlled("ai_controlled")
static constexpr int MAPSIZE_Y
@ MF_MILKABLE
Definition: mtype.h:167

References _, ACT_OPERATION, add_msg(), all_monsters(), cancel_activity_or_ignore_query(), cleanup_dead(), map::creature_in_field(), dbg, debug_mode, debugmsg, despawn_monster(), effect_ai_controlled, effect_npc_suspend, effect_ridden, Error, g, Character::get_power_level(), Character::has_active_bionic(), Creature::has_effect(), map::impassable(), is_empty(), m, m_debug, m_warning, MAPSIZE_X, MAPSIZE_Y, MF_MILKABLE, Character::mod_power_level(), motion_alarm, calendar::once_every(), map::points_in_radius(), Character::pos(), rl_dist(), string_format(), map::tername(), u, and avatar::wake_up().

Referenced by do_turn().

◆ mouse_edge_scrolling()

std::pair< tripoint, tripoint > game::mouse_edge_scrolling ( input_context ctxt,
int  speed,
const tripoint last,
bool  iso 
)
private

Definition at line 2354 of file game.cpp.

2356{
2357 const int rate = get_option<int>( "EDGE_SCROLL" );
2358 auto ret = std::make_pair( tripoint_zero, last );
2359 if( rate == -1 ) {
2360 // Fast return when the option is disabled.
2361 return ret;
2362 }
2363 // Ensure the parameters are used even if the #if below is false
2364 ( void ) ctxt;
2365 ( void ) speed;
2366 ( void ) iso;
2367#if (defined TILES || defined _WIN32 || defined WINDOWS)
2368 auto now = std::chrono::steady_clock::now();
2369 if( now < last_mouse_edge_scroll + std::chrono::milliseconds( rate ) ) {
2370 return ret;
2371 } else {
2373 }
2374 const input_event event = ctxt.get_raw_input();
2375 if( event.type == CATA_INPUT_MOUSE ) {
2376 const point threshold( projected_window_width() / 100, projected_window_height() / 100 );
2377 if( event.mouse_pos.x <= threshold.x ) {
2378 ret.first.x -= speed;
2379 if( iso ) {
2380 ret.first.y -= speed;
2381 }
2382 } else if( event.mouse_pos.x >= projected_window_width() - threshold.x ) {
2383 ret.first.x += speed;
2384 if( iso ) {
2385 ret.first.y += speed;
2386 }
2387 }
2388 if( event.mouse_pos.y <= threshold.y ) {
2389 ret.first.y -= speed;
2390 if( iso ) {
2391 ret.first.x += speed;
2392 }
2393 } else if( event.mouse_pos.y >= projected_window_height() - threshold.y ) {
2394 ret.first.y += speed;
2395 if( iso ) {
2396 ret.first.x -= speed;
2397 }
2398 }
2399 ret.second = ret.first;
2400 } else if( event.type == CATA_INPUT_TIMEOUT ) {
2401 ret.first = ret.second;
2402 }
2403#endif
2404 return ret;
2405}
@ CATA_INPUT_TIMEOUT
Definition: input.h:81
@ CATA_INPUT_MOUSE
Definition: input.h:84

References CATA_INPUT_MOUSE, CATA_INPUT_TIMEOUT, input_context::get_raw_input(), iso, last, last_mouse_edge_scroll, cata::hash64_detail::ret, tripoint_zero, point::x, and point::y.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ mouse_edge_scrolling_overmap()

tripoint game::mouse_edge_scrolling_overmap ( input_context ctxt)

This variant is suitable for the overmap.

Definition at line 2416 of file game.cpp.

2417{
2418 // overmap has no iso mode
2422 return ret.first;
2423}
std::pair< tripoint, tripoint > mouse_edge_scrolling(input_context &ctxt, int speed, const tripoint &last, bool iso)
Definition: game.cpp:2354
tripoint last_mouse_edge_scroll_vector_terrain
Definition: game.h:1117
tripoint last_mouse_edge_scroll_vector_overmap
Definition: game.h:1118

References last_mouse_edge_scroll_vector_overmap, last_mouse_edge_scroll_vector_terrain, mouse_edge_scrolling(), cata::hash64_detail::ret, and tripoint_zero.

◆ mouse_edge_scrolling_terrain()

tripoint game::mouse_edge_scrolling_terrain ( input_context ctxt)

Used to implement mouse "edge scrolling".

Returns a tripoint which is a vector of the resulting "move", i.e. (0, 0, 0) if the mouse is not at the edge of the screen, otherwise some (x, y, 0) depending on which edges are hit. This variant adjust scrolling speed according to zoom level, making it suitable when viewing the "terrain".

Definition at line 2407 of file game.cpp.

References DEFAULT_TILESET_ZOOM, last_mouse_edge_scroll_vector_overmap, last_mouse_edge_scroll_vector_terrain, mouse_edge_scrolling(), cata::hash64_detail::ret, tile_iso, tileset_zoom, and tripoint_zero.

Referenced by look_around().

◆ move_save_to_graveyard()

void game::move_save_to_graveyard ( const std::string &  dirname)
private

Definition at line 2788 of file game.cpp.

2789{
2790 const std::string save_dir = get_world_base_save_path();
2791 const std::string graveyard_dir = PATH_INFO::graveyarddir() + "/";
2792 const std::string graveyard_save_dir = graveyard_dir + dirname + "/";
2793 const std::string prefix = base64_encode( u.name ) + ".";
2794
2795 if( !assure_dir_exist( graveyard_dir ) ) {
2796 debugmsg( "could not create graveyard path '%s'", graveyard_dir );
2797 }
2798
2799 if( !assure_dir_exist( graveyard_save_dir ) ) {
2800 debugmsg( "could not create graveyard path '%s'", graveyard_save_dir );
2801 }
2802
2803 const auto save_files = get_files_from_path( prefix, save_dir );
2804 if( save_files.empty() ) {
2805 debugmsg( "could not find save files in '%s'", save_dir );
2806 }
2807
2808 for( const auto &src_path : save_files ) {
2809 const std::string dst_path = graveyard_save_dir +
2810 src_path.substr( src_path.rfind( '/' ), std::string::npos );
2811
2812 if( rename_file( src_path, dst_path ) ) {
2813 continue;
2814 }
2815
2816 debugmsg( "could not rename file '%s' to '%s'", src_path, dst_path );
2817
2818 if( remove_file( src_path ) ) {
2819 continue;
2820 }
2821
2822 debugmsg( "could not remove file '%s'", src_path );
2823 }
2824}
@ prefix
Definition: enums.h:79
bool remove_file(const std::string &path)
Remove a file.
Definition: filesystem.cpp:89
bool assure_dir_exist(const std::string &path)
Create directory if it does not exist.
Definition: filesystem.cpp:48
bool rename_file(const std::string &old_path, const std::string &new_path)
Rename a file, overwriting the target.
Definition: filesystem.cpp:105
std::vector< std::string > get_files_from_path(const std::string &pattern, const std::string &root_path, const bool recursive_search, const bool match_extension)
Returns a vector of files or directories matching pattern at root_path.
Definition: filesystem.cpp:362
std::string graveyarddir()
Definition: path_info.cpp:202

References assure_dir_exist(), base64_encode(), debugmsg, get_files_from_path(), get_world_base_save_path(), PATH_INFO::graveyarddir(), Character::name, prefix, remove_file(), rename_file(), and u.

Referenced by cleanup_at_end().

◆ moving_vehicle_dismount()

void game::moving_vehicle_dismount ( const tripoint dest_loc)

Handles players exiting from moving vehicles.

Definition at line 5434 of file game.cpp.

5435{
5436 const optional_vpart_position vp = m.veh_at( u.pos() );
5437 if( !vp ) {
5438 debugmsg( "Tried to exit non-existent vehicle." );
5439 return;
5440 }
5441 vehicle *const veh = &vp->vehicle();
5442 if( u.pos() == dest_loc ) {
5443 debugmsg( "Need somewhere to dismount towards." );
5444 return;
5445 }
5446 tileray ray( dest_loc.xy() + point( -u.posx(), -u.posy() ) );
5447 // TODO:: make dir() const correct!
5448 const units::angle d = ray.dir();
5449 add_msg( _( "You dive from the %s." ), veh->name );
5450 m.unboard_vehicle( u.pos() );
5451 u.moves -= 200;
5452 // Dive three tiles in the direction of tox and toy
5453 fling_creature( &u, d, 30, true );
5454 // Hit the ground according to vehicle speed
5455 if( !m.has_flag( "SWIMMABLE", u.pos() ) ) {
5456 if( veh->velocity > 0 ) {
5457 fling_creature( &u, veh->face.dir(), veh->velocity / static_cast<float>( 100 ) );
5458 } else {
5459 fling_creature( &u, veh->face.dir() + 180_degrees,
5460 -( veh->velocity ) / static_cast<float>( 100 ) );
5461 }
5462 }
5463}
void fling_creature(Creature *c, const units::angle &dir, float flvel, bool controlled=false, bool suppress_map_update=false)
Flings the input creature in the given direction.
Definition: game.cpp:10324

References _, add_msg(), debugmsg, tileray::dir(), vehicle::face, fling_creature(), map::has_flag(), m, Creature::moves, vehicle::name, Character::pos(), Character::posx(), Character::posy(), u, map::unboard_vehicle(), map::veh_at(), vehicle::velocity, and tripoint::xy().

◆ natural_light_level()

float game::natural_light_level ( int  zlev) const

Definition at line 3869 of file game.cpp.

3870{
3871 // ignore while underground or above limits
3872 if( zlev > OVERMAP_HEIGHT || zlev < 0 ) {
3873 return LIGHT_AMBIENT_MINIMAL;
3874 }
3875
3876 if( latest_lightlevels[zlev] > -std::numeric_limits<float>::max() ) {
3877 // Already found the light level for now?
3878 return latest_lightlevels[zlev];
3879 }
3880
3881 float ret = LIGHT_AMBIENT_MINIMAL;
3882
3883 // Sunlight/moonlight related stuff
3885 if( !weather.lightning_active ) {
3887 } else {
3888 // Recent lightning strike has lit the area
3890 }
3891
3893
3894 // Artifact light level changes here. Even though some of these only have an effect
3895 // aboveground it is cheaper performance wise to simply iterate through the entire
3896 // list once instead of twice.
3897 float mod_ret = -1;
3898 // Each artifact change does std::max(mod_ret, new val) since a brighter end value
3899 // will trump a lower one.
3900 if( const timed_event *e = timed_events.get( TIMED_EVENT_DIM ) ) {
3901 // TIMED_EVENT_DIM slowly dims the natural sky level, then relights it.
3902 const time_duration left = e->when - calendar::turn;
3903 // TIMED_EVENT_DIM has an occurrence date of turn + 50, so the first 25 dim it,
3904 if( left > 25_turns ) {
3905 mod_ret = std::max( static_cast<double>( mod_ret ), ( ret * ( left - 25_turns ) ) / 25_turns );
3906 // and the last 25 scale back towards normal.
3907 } else {
3908 mod_ret = std::max( static_cast<double>( mod_ret ), ( ret * ( 25_turns - left ) ) / 25_turns );
3909 }
3910 }
3912 // TIMED_EVENT_ARTIFACT_LIGHT causes everywhere to become as bright as day.
3913 mod_ret = std::max<float>( ret, default_daylight_level() );
3914 }
3915 // If we had a changed light level due to an artifact event then it overwrites
3916 // the natural light level.
3917 if( mod_ret > -1 ) {
3918 ret = mod_ret;
3919 }
3920
3921 // Cap everything to our minimum light level
3922 ret = std::max<float>( LIGHT_AMBIENT_MINIMAL, ret );
3923
3924 latest_lightlevels[zlev] = ret;
3925
3926 return ret;
3927}
double default_daylight_level()
How much light is provided in full daylight.
Definition: calendar.cpp:62
float sunlight(const time_point &p, const bool vision)
Returns the current sunlight or moonlight level through the preceding functions.
Definition: calendar.cpp:199
std::array< float, OVERMAP_LAYERS > latest_lightlevels
Definition: game.h:1090
bool queued(timed_event_type type) const
timed_event * get(timed_event_type type)
weather_type_id weather_id
Definition: weather.h:193
static constexpr float LIGHT_AMBIENT_MINIMAL
Definition: lightmap.h:12
@ TIMED_EVENT_DIM
Definition: timed_event.h:22
@ TIMED_EVENT_ARTIFACT_LIGHT
Definition: timed_event.h:23

References default_daylight_level(), timed_event_manager::get(), get_weather, latest_lightlevels, left, LIGHT_AMBIENT_MINIMAL, weather_type::light_modifier, OVERMAP_HEIGHT, timed_event_manager::queued(), cata::hash64_detail::ret, sunlight(), TIMED_EVENT_ARTIFACT_LIGHT, TIMED_EVENT_DIM, timed_events, calendar::turn, and weather_manager::weather_id.

Referenced by light_level().

◆ npc_menu()

bool game::npc_menu ( npc who)

Returns true if the menu handled stuff and player shouldn't do anything else.

Perception slightly increases precision when examining NPCs' wounds Firstaid increases precision when examining NPCs' wounds

Definition at line 5565 of file game.cpp.

5566{
5567 enum choices : int {
5568 talk = 0,
5569 swap_pos,
5570 push,
5571 examine_wounds,
5572 use_item,
5573 sort_armor,
5574 attack,
5575 disarm,
5576 steal
5577 };
5578
5579 const bool obeys = debug_mode || ( who.is_player_ally() && !who.in_sleep_state() );
5580
5581 uilist amenu;
5582
5583 amenu.text = string_format( _( "What to do with %s?" ), who.disp_name() );
5584 amenu.addentry( talk, true, 't', _( "Talk" ) );
5585 amenu.addentry( swap_pos, obeys && !who.is_mounted() &&
5586 !u.is_mounted(), 's', _( "Swap positions" ) );
5587 amenu.addentry( push, obeys && !who.is_mounted(), 'p', _( "Push away" ) );
5588 amenu.addentry( examine_wounds, true, 'w', _( "Examine wounds" ) );
5589 amenu.addentry( use_item, true, 'i', _( "Use item on" ) );
5590 amenu.addentry( sort_armor, true, 'r', _( "Sort armor" ) );
5591 amenu.addentry( attack, true, 'a', _( "Attack" ) );
5592 if( !who.is_player_ally() ) {
5593 amenu.addentry( disarm, who.is_armed(), 'd', _( "Disarm" ) );
5594 amenu.addentry( steal, !who.is_enemy(), 'S', _( "Steal" ) );
5595 }
5596
5597 amenu.query();
5598
5599 const int choice = amenu.ret;
5600 if( choice == talk ) {
5601 who.talk_to_u();
5602 } else if( choice == swap_pos ) {
5603 if( !prompt_dangerous_tile( who.pos() ) ) {
5604 return true;
5605 }
5606 // TODO: Make NPCs protest when displaced onto dangerous crap
5607 add_msg( _( "You swap places with %s." ), who.name );
5608 swap_critters( u, who );
5609 // TODO: Make that depend on stuff
5610 u.mod_moves( -200 );
5611 } else if( choice == push ) {
5612 // TODO: Make NPCs protest when displaced onto dangerous crap
5613 tripoint oldpos = who.pos();
5614 who.move_away_from( u.pos(), true );
5615 u.mod_moves( -20 );
5616 if( oldpos != who.pos() ) {
5617 add_msg( _( "%s moves out of the way." ), who.name );
5618 } else {
5619 add_msg( m_warning, _( "%s has nowhere to go!" ), who.name );
5620 }
5621 } else if( choice == examine_wounds ) {
5622 ///\EFFECT_PER slightly increases precision when examining NPCs' wounds
5623
5624 ///\EFFECT_FIRSTAID increases precision when examining NPCs' wounds
5625 const bool precise = u.get_skill_level( skill_firstaid ) * 4 + u.per_cur >= 20;
5626 who.body_window( _( "Limbs of: " ) + who.disp_name(), true, precise, 0, 0, 0, 0.0f, 0.0f, 0.0f,
5627 0.0f, 0.0f );
5628 } else if( choice == use_item ) {
5629 static const std::string heal_string( "heal" );
5630 const auto will_accept = []( const item & it ) {
5631 const auto use_fun = it.get_use( heal_string );
5632 if( use_fun == nullptr ) {
5633 return false;
5634 }
5635
5636 const auto *actor = dynamic_cast<const heal_actor *>( use_fun->get_actor_ptr() );
5637
5638 return actor != nullptr &&
5639 actor->limb_power >= 0 &&
5640 actor->head_power >= 0 &&
5641 actor->torso_power >= 0;
5642 };
5643 item_location loc = game_menus::inv::titled_filter_menu( will_accept, u, _( "Use which item?" ) );
5644
5645 if( !loc ) {
5646 add_msg( _( "Never mind" ) );
5647 return false;
5648 }
5649 item &used = *loc;
5650 bool did_use = u.invoke_item( &used, heal_string, who.pos() );
5651 if( did_use ) {
5652 // Note: exiting a body part selection menu counts as use here
5653 u.mod_moves( -300 );
5654 }
5655 } else if( choice == sort_armor ) {
5656 who.sort_armor();
5657 u.mod_moves( -100 );
5658 } else if( choice == attack ) {
5659 if( who.is_enemy() || query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5660 u.melee_attack( who, true );
5661 who.on_attacked( u );
5662 }
5663 } else if( choice == disarm ) {
5664 if( who.is_enemy() || query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5665 u.disarm( who );
5666 }
5667 } else if( choice == steal && query_yn( _( "You may be attacked! Proceed?" ) ) ) {
5668 u.steal( who );
5669 }
5670
5671 return true;
5672}
hp_part body_window(const std::string &menu_header, bool show_all, bool precise, int normal_bonus, int head_bonus, int torso_bonus, float bleed, float bite, float infect, float bandage_power, float disinfectant_power) const
Displays menu with body part hp, optionally with hp estimation after healing.
Definition: character.cpp:5863
bool in_sleep_state() const override
Definition: character.cpp:9334
void melee_attack(Creature &t, bool allow_special, const matec_id &force_technique, bool allow_unarmed=true)
Sets up a melee attack and handles melee attack function calls.
Definition: melee.cpp:390
int per_cur
Definition: character.h:249
void steal(npc &target)
Try to steal an item from the NPC's inventory.
Definition: melee.cpp:2369
bool prompt_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:9264
bool swap_critters(Creature &, Creature &)
Swaps positions of two creatures.
Definition: game.cpp:5091
float limb_power
How much hp to restore when healing limbs?
Definition: iuse_actor.h:1011
void talk_to_u(bool radio_contact=false)
Definition: npctalk.cpp:731
void on_attacked(const Creature &attacker)
Definition: npc.cpp:1446
void move_away_from(const tripoint &p, bool no_bash_atk=false, std::set< tripoint > *nomove=nullptr)
Definition: npcmove.cpp:2530
void disarm(npc &target)
Try to disarm the NPC.
Definition: melee.cpp:2293
static const skill_id skill_firstaid("firstaid")
static void swap_pos(Creature &caster, const tripoint &target)
item_location steal(avatar &you, player &victim)
Menu for stealing stuff.
item_location titled_filter_menu(item_filter filter, avatar &you, const std::string &title, const std::string &none_message="")
void push(monster &z)
Definition: monexamine.cpp:552

References _, add_msg(), uilist::addentry(), Character::body_window(), debug_mode, player::disarm(), Character::disp_name(), Character::get_skill_level(), Character::in_sleep_state(), avatar::invoke_item(), Character::is_armed(), npc::is_enemy(), Character::is_mounted(), npc::is_player_ally(), heal_actor::limb_power, m_warning, Character::melee_attack(), Creature::mod_moves(), npc::move_away_from(), Character::name, npc::on_attacked(), Character::per_cur, Character::pos(), prompt_dangerous_tile(), monexamine::push(), uilist::query(), query_yn(), uilist::ret, skill_firstaid, player::sort_armor(), game_menus::inv::steal(), avatar::steal(), string_format(), swap_critters(), swap_pos(), npc::talk_to_u(), uilist::text, game_menus::inv::titled_filter_menu(), u, and avatar_action::use_item().

Referenced by examine().

◆ num_creatures()

size_t game::num_creatures ( ) const

Returns the approximate number of creatures in the reality bubble.

Because of performance restrictions it may return a slightly incorrect values (as it includes dead, but not yet cleaned up creatures).

Definition at line 5036 of file game.cpp.

5037{
5038 return critter_tracker->size() + active_npc.size() + 1; // 1 == g->u
5039}

References active_npc, and critter_tracker.

Referenced by display_visibility(), and fungal_effects::fungalize().

◆ on_move_effects()

void game::on_move_effects ( )

Definition at line 10282 of file game.cpp.

10283{
10284 // TODO: Move this to a character method
10285 if( !u.is_mounted() ) {
10286 const item muscle( "muscle" );
10287 for( const bionic_id &bid : u.get_bionic_fueled_with( muscle ) ) {
10288 if( u.has_active_bionic( bid ) ) {// active power gen
10289 u.mod_power_level( units::from_kilojoule( muscle.fuel_energy() ) * bid->fuel_efficiency );
10290 } else if( u.has_bionic( bid ) ) {// passive power gen
10291 u.mod_power_level( units::from_kilojoule( muscle.fuel_energy() ) * bid->passive_fuel_efficiency );
10292 }
10293 }
10294
10295 if( u.has_active_bionic( bionic_id( "bio_jointservo" ) ) ) {
10296 if( u.movement_mode_is( CMM_RUN ) ) {
10297 u.mod_power_level( -55_J );
10298 } else {
10299 u.mod_power_level( -35_J );
10300 }
10301 }
10302 }
10303
10304 if( u.movement_mode_is( CMM_RUN ) ) {
10305 if( !u.can_run() ) {
10307 }
10308 }
10309
10310 // apply martial art move bonuses
10311 u.martial_arts_data->ma_onmove_effects( u );
10312
10314}
@ CMM_RUN
Definition: character.h:102
bool can_run()
source of truth of whether a Character can run
Definition: character.cpp:1332
bool movement_mode_is(character_movemode mode) const
Check against the character's current movement mode.
Definition: character.cpp:1622
std::vector< bionic_id > get_bionic_fueled_with(const item &it) const
Return bionic_id of bionics able to use it as fuel.
Definition: character.cpp:1931
bool has_bionic(const bionic_id &b) const
Returns true if the player has the entered bionic id.
Definition: character.cpp:1880
void do_ambient()
Definition: sounds.cpp:1616
constexpr quantity< value_type, energy_in_joule_tag > from_kilojoule(const value_type v)
Definition: units_energy.h:32

References Character::can_run(), CMM_RUN, sfx::do_ambient(), units::from_kilojoule(), item::fuel_energy(), Character::get_bionic_fueled_with(), Character::has_active_bionic(), Character::has_bionic(), Character::is_mounted(), Character::martial_arts_data, Character::mod_power_level(), Character::movement_mode_is(), avatar::toggle_run_mode(), and u.

Referenced by phasing_move(), and walk_move().

◆ on_options_changed()

void game::on_options_changed ( )

Should be invoked whenever options change.

Definition at line 10316 of file game.cpp.

10317{
10318#if defined(TILES)
10319 tilecontext->on_options_changed();
10320#endif
10321 grid_tracker_ptr->on_options_changed();
10322}

References grid_tracker_ptr.

◆ open_consume_item_menu()

void game::open_consume_item_menu ( )
private

Definition at line 1487 of file handle_action.cpp.

1488{
1489 uilist as_m;
1490
1491 as_m.text = _( "What do you want to consume?" );
1492
1493 as_m.entries.emplace_back( 0, true, 'f', _( "Food" ) );
1494 as_m.entries.emplace_back( 1, true, 'd', _( "Drink" ) );
1495 as_m.entries.emplace_back( 2, true, 'm', _( "Medication" ) );
1496 as_m.query();
1497
1498 switch( as_m.ret ) {
1499 case 0:
1501 break;
1502 case 1:
1504 break;
1505 case 2:
1507 break;
1508 default:
1509 break;
1510 }
1511}
item_location consume_drink(player &p)
Consuming a drink item via a custom menu.
item_location consume_meds(player &p)
Consuming a medication item via a custom menu.
item_location consume_food(player &p)
Consuming a food item via a custom menu.

References _, game_menus::inv::consume_drink(), game_menus::inv::consume_food(), game_menus::inv::consume_meds(), avatar_action::eat(), uilist::entries, uilist::query(), uilist::ret, uilist::text, and u.

Referenced by handle_action().

◆ open_gate()

void game::open_gate ( const tripoint p)

Definition at line 5429 of file game.cpp.

5430{
5431 gates::open_gate( p, u );
5432}
void open_gate(const tripoint &pos, player &p)
opens the gate via player's activity
Definition: gates.cpp:236

References gates::open_gate(), and u.

◆ overmap_npc_move()

void game::overmap_npc_move ( )
private

Definition at line 4537 of file game.cpp.

4538{
4539 std::vector<npc *> travelling_npcs;
4540 static constexpr int move_search_radius = 600;
4541 for( auto &elem : overmap_buffer.get_npcs_near_player( move_search_radius ) ) {
4542 if( !elem ) {
4543 continue;
4544 }
4545 npc *npc_to_add = elem.get();
4546 if( ( !npc_to_add->is_active() || rl_dist( u.pos(), npc_to_add->pos() ) > SEEX * 2 ) &&
4547 npc_to_add->mission == NPC_MISSION_TRAVELLING ) {
4548 travelling_npcs.push_back( npc_to_add );
4549 }
4550 }
4551 for( auto &elem : travelling_npcs ) {
4552 if( elem->has_omt_destination() ) {
4553 if( !elem->omt_path.empty() && rl_dist( elem->omt_path.back(), elem->global_omt_location() ) > 2 ) {
4554 //recalculate path, we got distracted doing something else probably
4555 elem->omt_path.clear();
4556 }
4557 if( elem->omt_path.empty() ) {
4558 const tripoint_abs_omt &from = elem->global_omt_location();
4559 const tripoint_abs_omt &to = elem->goal;
4560 elem->omt_path = overmap_buffer.get_travel_path( elem->global_omt_location(), elem->goal,
4562 if( elem->omt_path.empty() ) {
4563 add_msg( m_debug, "%s couldn't find overmap path from %s to %s",
4564 elem->get_name(), from.to_string(), to.to_string() );
4565 elem->goal = npc::no_goal_point;
4566 elem->mission = NPC_MISSION_NULL;
4567 }
4568 } else {
4569 if( elem->omt_path.back() == elem->global_omt_location() ) {
4570 elem->omt_path.pop_back();
4571 }
4572 // TODO: fix point types
4573 elem->travel_overmap(
4574 project_to<coords::sm>( elem->omt_path.back() ).raw() );
4575 }
4576 reload_npcs();
4577 }
4578 }
4579 return;
4580}
std::vector< tripoint_abs_omt > omt_path
Definition: character.h:972
static constexpr tripoint_abs_omt no_goal_point
Definition: npc.h:1338
bool is_active() const
Definition: npc.cpp:2192
std::vector< tripoint_abs_omt > get_travel_path(const tripoint_abs_omt &src, const tripoint_abs_omt &dest, overmap_path_params params)
@ NPC_MISSION_NULL
Definition: npc.h:179
@ NPC_MISSION_TRAVELLING
Definition: npc.h:191
static overmap_path_params for_npc()

References add_msg(), overmap_path_params::for_npc(), overmapbuffer::get_npcs_near_player(), overmapbuffer::get_travel_path(), npc::is_active(), m_debug, npc::mission, npc::no_goal_point, NPC_MISSION_NULL, NPC_MISSION_TRAVELLING, Character::omt_path, overmap_buffer, Character::pos(), reload_npcs(), rl_dist(), SEEX, coords::coord_point< Point, Origin, Scale >::to_string(), and u.

Referenced by do_turn().

◆ peek() [1/2]

void game::peek ( )

Definition at line 5924 of file game.cpp.

5925{
5926 const cata::optional<tripoint> p = choose_direction( _( "Peek where?" ), true );
5927 if( !p ) {
5928 return;
5929 }
5930
5931 if( p->z != 0 ) {
5932 const tripoint old_pos = u.pos();
5933 vertical_move( p->z, false, true );
5934
5935 if( old_pos != u.pos() ) {
5936 look_around();
5937 vertical_move( p->z * -1, false, true );
5938 }
5939 return;
5940 }
5941
5942 if( m.impassable( u.pos() + *p ) || m.obstructed_by_vehicle_rotation( u.pos(), u.pos() + *p ) ) {
5943 return;
5944 }
5945
5946 peek( u.pos() + *p );
5947}
cata::optional< tripoint > choose_direction(const std::string &message, const bool allow_vertical)
Request player input of a direction, possibly including vertical component.
Definition: action.cpp:975

References _, choose_direction(), map::impassable(), look_around(), m, map::obstructed_by_vehicle_rotation(), peek(), Character::pos(), u, and vertical_move().

Referenced by handle_action(), and peek().

◆ peek() [2/2]

void game::peek ( const tripoint p)

Definition at line 5949 of file game.cpp.

5950{
5951 u.moves -= 200;
5952 tripoint prev = u.pos();
5953 u.setpos( p );
5954 tripoint center = p;
5955 const look_around_result result = look_around( /*show_window=*/true, center, center, false, false,
5956 true );
5957 u.setpos( prev );
5958
5959 if( result.peek_action && *result.peek_action == PA_BLIND_THROW ) {
5960 item_location loc;
5961 avatar_action::plthrow( u, loc, p );
5962 }
5964}

References center, map::invalidate_map_cache(), look_around(), m, Creature::moves, PA_BLIND_THROW, avatar_action::plthrow(), Character::pos(), Character::setpos(), u, and tripoint::z.

◆ perhaps_add_random_npc()

void game::perhaps_add_random_npc ( )
private

Definition at line 11612 of file game.cpp.

11613{
11614 if( !calendar::once_every( 1_hours ) ) {
11615 return;
11616 }
11617 // Create a new NPC?
11618 // Only allow NPCs on 0 z-level, otherwise they can bug out due to lack of spots
11619 if( !get_option<bool>( "RANDOM_NPC" ) || ( !m.has_zlevels() && get_levz() != 0 ) ) {
11620 return;
11621 }
11622
11623 float density = get_option<float>( "NPC_DENSITY" );
11624 static constexpr int density_search_radius = 60;
11625 const float npc_num = overmap_buffer.get_npcs_near_player( density_search_radius ).size();
11626 if( npc_num > 0.0 ) {
11627 // 100%, 80%, 64%, 52%, 41%, 33%...
11628 density *= std::pow( 0.8f, npc_num );
11629 }
11630
11631 if( !x_in_y( density, 100 ) ) {
11632 return;
11633 }
11634 bool spawn_allowed = false;
11636 int counter = 0;
11637 while( !spawn_allowed ) {
11638 if( counter >= 10 ) {
11639 return;
11640 }
11641 static constexpr int radius_spawn_range = 120;
11642 const tripoint_abs_omt u_omt = u.global_omt_location();
11643 spawn_point = u_omt + point( rng( -radius_spawn_range, radius_spawn_range ),
11644 rng( -radius_spawn_range, radius_spawn_range ) );
11645 spawn_point.z() = 0;
11646 const oter_id oter = overmap_buffer.ter( spawn_point );
11647 // shouldn't spawn on lakes or rivers.
11648 if( !is_river_or_lake( oter ) ) {
11649 spawn_allowed = true;
11650 }
11651 counter += 1;
11652 }
11653 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
11654 tmp->normalize();
11655 tmp->randomize();
11656 std::string new_fac_id = "solo_";
11657 new_fac_id += tmp->name;
11658 // create a new "lone wolf" faction for this one NPC
11659 faction *new_solo_fac = faction_manager_ptr->add_new_faction( tmp->name, faction_id( new_fac_id ),
11660 faction_id( "no_faction" ) );
11661 tmp->set_fac( new_solo_fac ? new_solo_fac->id : faction_id( "no_faction" ) );
11662 // adds the npc to the correct overmap.
11663 // Only spawn random NPCs on z-level 0
11664 // TODO: fix point types
11665 tripoint submap_spawn = omt_to_sm_copy( spawn_point.raw() );
11666 tmp->spawn_at_sm( tripoint( submap_spawn.xy(), 0 ) );
11668 tmp->form_opinion( u );
11669 tmp->mission = NPC_MISSION_NULL;
11670 tmp->long_term_goal_action();
11671 tmp->add_new_mission( mission::reserve_random( ORIGIN_ANY_NPC, tmp->global_omt_location(),
11672 tmp->getID() ) );
11673 // This will make the new NPC active- if its nearby to the player
11674 load_npcs();
11675}
faction_id id
Definition: faction.h:82
point omt_to_sm_copy(const point &p)
@ ORIGIN_ANY_NPC
Definition: mission.h:46
bool is_river_or_lake(const oter_id &ter)
Definition: overmap.cpp:563

References faction_manager_ptr, get_levz(), overmapbuffer::get_npcs_near_player(), Character::global_omt_location(), map::has_zlevels(), faction_template::id, overmapbuffer::insert_npc(), is_river_or_lake(), load_npcs(), m, NPC_MISSION_NULL, omt_to_sm_copy(), calendar::once_every(), ORIGIN_ANY_NPC, overmap_buffer, mission::reserve_random(), rng(), overmapbuffer::ter(), u, x_in_y(), and tripoint::xy().

Referenced by do_turn().

◆ phasing_move()

bool game::phasing_move ( const tripoint dest,
bool  via_ramp = false 
)

Definition at line 10014 of file game.cpp.

10015{
10016 if( dest_loc.z != u.posz() && !via_ramp ) {
10017 // No vertical phasing yet
10018 return false;
10019 }
10020
10021 //probability travel through walls but not water
10022 tripoint dest = dest_loc;
10023 // tile is impassable
10024 int tunneldist = 0;
10025 const point d( sgn( dest.x - u.posx() ), sgn( dest.y - u.posy() ) );
10026 while( m.impassable( dest ) ||
10027 ( critter_at( dest ) != nullptr && tunneldist > 0 ) ) {
10028 //add 1 to tunnel distance for each impassable tile in the line
10029 tunneldist += 1;
10030 //Being dimensionally anchored prevents quantum shenanigans.
10031 if( u.worn_with_flag( "DIMENSIONAL_ANCHOR" ) || u.has_effect_with_flag( "DIMENSIONAL_ANCHOR" ) ) {
10033 _( "You try to quantum tunnel through the barrier, but something holds you back!" ) );
10034 return false;
10035 }
10036
10037 if( tunneldist > 24 ) {
10038 add_msg( m_info, _( "It's too dangerous to tunnel that far!" ) );
10039 return false;
10040 }
10041
10042 dest.x += d.x;
10043 dest.y += d.y;
10044 }
10045
10046 if( tunneldist != 0 ) {
10047 if( ( tunneldist - 1 ) * 100_kJ
10048 > //The first 100 was already taken up by the bionic's activation cost.
10049 u.get_power_level() ) { //oops, not enough energy! Tunneling costs 100 bionic power per impassable tile
10050 if( tunneldist * 100_kJ >
10052 add_msg( _( "You try to quantum tunnel through the barrier but bounce off! You don't have enough bionic power capacity to travel that far." ) );
10053 } else {
10054 add_msg( _( "You try to quantum tunnel through the barrier but are reflected! You need %i bionic power to travel that thickness of material." ),
10055 ( 100 * tunneldist ) );
10056 }
10057 return false;
10058 }
10059
10060 if( u.in_vehicle ) {
10061 m.unboard_vehicle( u.pos() );
10062 }
10063
10064 add_msg( _( "You quantum tunnel through the %d-tile wide barrier!" ), tunneldist );
10065 //tunneling costs 100 bionic power per impassable tile, but the first 100 was already drained by activation.
10066 u.mod_power_level( -( ( tunneldist - 1 ) * 100_kJ ) );
10067 //tunneling costs 100 moves baseline, 50 per extra tile up to a cap of 500 moves
10068 u.moves -= ( 50 + ( tunneldist * 50 ) );
10069 u.setpos( dest );
10070
10071 if( m.veh_at( u.pos() ).part_with_feature( "BOARDABLE", true ) ) {
10072 m.board_vehicle( u.pos(), &u );
10073 }
10074
10075 u.grab( OBJECT_NONE );
10077 m.creature_on_trap( u );
10078 return true;
10079 }
10080
10081 return false;
10082}
bool worn_with_flag(const std::string &flag, const bodypart_id &bp=bodypart_str_id::NULL_ID()) const
Returns true if the player is wearing an item with the given flag.
Definition: character.cpp:3273
units::energy get_max_power_level() const
Definition: character.cpp:1975
bool has_effect_with_flag(const std::string &flag, body_part bp=num_bp) const
Check if creature has any effect with the given flag.
Definition: creature.cpp:1201
void on_move_effects()
Definition: game.cpp:10282
void board_vehicle(const tripoint &p, player *pl)
Definition: map.cpp:1044
constexpr int sgn(const T x)
Definition: enums.h:8

References _, add_msg(), player::add_msg_if_player(), map::board_vehicle(), map::creature_on_trap(), critter_at(), Character::get_max_power_level(), Character::get_power_level(), avatar::grab(), Creature::has_effect_with_flag(), map::impassable(), Character::in_vehicle, m, m_info, Character::mod_power_level(), Creature::moves, OBJECT_NONE, on_move_effects(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), Character::setpos(), sgn(), u, map::unboard_vehicle(), map::veh_at(), Character::worn_with_flag(), point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

◆ pickup() [1/2]

void game::pickup ( )
private

Definition at line 5895 of file game.cpp.

5896{
5897 const cata::optional<tripoint> examp_ = choose_adjacent_highlight( _( "Pickup where?" ),
5898 _( "There is nothing to pick up nearby." ),
5899 ACTION_PICKUP, false );
5900 if( !examp_ ) {
5901 return;
5902 }
5903 pickup( *examp_ );
5904}

References _, ACTION_PICKUP, choose_adjacent_highlight(), and pickup().

Referenced by handle_action(), and pickup().

◆ pickup() [2/2]

void game::pickup ( const tripoint p)
private

Definition at line 5906 of file game.cpp.

5907{
5908 // Highlight target
5909 shared_ptr_fast<game::draw_callback_t> hilite_cb = make_shared_fast<game::draw_callback_t>( [&]() {
5910 m.drawsq( w_terrain, p, drawsq_params().highlight( true ) );
5911 } );
5912 add_draw_callback( hilite_cb );
5913
5914 pickup::pick_up( p, 0 );
5915}

References add_draw_callback(), map::drawsq(), m, pickup::pick_up(), and w_terrain.

◆ pickup_feet()

void game::pickup_feet ( )
private

Definition at line 5917 of file game.cpp.

5918{
5919 pickup::pick_up( u.pos(), 1 );
5920}

References pickup::pick_up(), Character::pos(), and u.

Referenced by handle_action().

◆ place_critter_around() [1/2]

monster * game::place_critter_around ( const mtype_id id,
const tripoint center,
int  radius 
)

Definition at line 4984 of file game.cpp.

4985{
4986 // TODO: change this into an assert, it must never happen.
4987 if( id.is_null() ) {
4988 return nullptr;
4989 }
4990 return place_critter_around( make_shared_fast<monster>( id ), center, radius );
4991}
monster * place_critter_around(const mtype_id &id, const tripoint &center, int radius)
Definition: game.cpp:4984

References center, and place_critter_around().

Referenced by place_critter_around(), place_critter_at(), replace_stair_monsters(), and start_game().

◆ place_critter_around() [2/2]

monster * game::place_critter_around ( const shared_ptr_fast< monster > &  mon,
const tripoint center,
int  radius,
bool  forced = false 
)

Definition at line 4993 of file game.cpp.

4997{
4999 if( forced || can_place_monster( *mon, center ) ) {
5000 where = center;
5001 }
5002
5003 // This loop ensures the monster is placed as close to the center as possible,
5004 // but all places that equally far from the center have the same probability.
5005 for( int r = 1; r <= radius && !where; ++r ) {
5007 }
5008
5009 if( !where ) {
5010 return nullptr;
5011 }
5012 mon->spawn( *where );
5013 return critter_tracker->add( mon ) ? mon.get() : nullptr;
5014}
static cata::optional< tripoint > choose_where_to_place_monster(const monster &mon, const tripoint_range< tripoint > &range)
Definition: game.cpp:4966
static bool can_place_monster(const monster &mon, const tripoint &p)
Definition: game.cpp:4950

References can_place_monster(), center, choose_where_to_place_monster(), critter_tracker, m, and map::points_in_radius().

◆ place_critter_at() [1/2]

monster * game::place_critter_at ( const mtype_id id,
const tripoint p 
)

Adds critters to the reality bubble, creating them if necessary.

Functions taking a id parameter will construct a monster based on that id, (with default properties). Functions taking a mon parameter will use the supplied monster instance instead (which must not be null). Note: the monster will not be upgraded by these functions, it is placed as is.

place_critter_at will place the creature exactly at the given point.

place_critter_around will place the creature around the center p within the given radius (radius 0 means only the center point is used). The chosen point will be as close to the center as possible.

place_critter_within will place the creature at a random point within that given range. (All points within have equal probability.)

Returns
All functions return null if the creature could not be placed (usually because the target is not suitable for it: may be a solid wall, or air, or already occupied by some creature). If the creature has been placed, it returns a pointer to it (which is the same as the one contained in mon).

Definition at line 4974 of file game.cpp.

4975{
4976 return place_critter_around( id, p, 0 );
4977}

References place_critter_around().

Referenced by fungal_effects::fungalize(), revive_corpse(), fungal_effects::spread_fungus_one_tile(), and update_stair_monsters().

◆ place_critter_at() [2/2]

monster * game::place_critter_at ( const shared_ptr_fast< monster > &  mon,
const tripoint p 
)

Definition at line 4979 of file game.cpp.

4980{
4981 return place_critter_around( mon, p, 0 );
4982}

References place_critter_around().

◆ place_critter_within() [1/2]

monster * game::place_critter_within ( const mtype_id id,
const tripoint_range< tripoint > &  range 
)

Definition at line 5016 of file game.cpp.

5017{
5018 // TODO: change this into an assert, it must never happen.
5019 if( id.is_null() ) {
5020 return nullptr;
5021 }
5022 return place_critter_within( make_shared_fast<monster>( id ), range );
5023}
monster * place_critter_within(const mtype_id &id, const tripoint_range< tripoint > &range)
Definition: game.cpp:5016

References place_critter_within().

Referenced by place_critter_within().

◆ place_critter_within() [2/2]

monster * game::place_critter_within ( const shared_ptr_fast< monster > &  mon,
const tripoint_range< tripoint > &  range 
)

Definition at line 5025 of file game.cpp.

5027{
5028 const cata::optional<tripoint> where = choose_where_to_place_monster( *mon, range );
5029 if( !where ) {
5030 return nullptr;
5031 }
5032 mon->spawn( *where );
5033 return critter_tracker->add( mon ) ? mon.get() : nullptr;
5034}

References choose_where_to_place_monster(), and critter_tracker.

◆ place_player()

point game::place_player ( const tripoint dest)
Dexterity increases chance of avoiding cuts on sharp terrain

Definition at line 9652 of file game.cpp.

9653{
9654 const optional_vpart_position vp1 = m.veh_at( dest_loc );
9655 if( const cata::optional<std::string> label = vp1.get_label() ) {
9656 add_msg( m_info, _( "Label here: %s" ), *label );
9657 }
9658 std::string signage = m.get_signage( dest_loc );
9659 if( !signage.empty() ) {
9660 if( !u.has_trait( trait_ILLITERATE ) ) {
9661 add_msg( m_info, _( "The sign says: %s" ), signage );
9662 } else {
9663 add_msg( m_info, _( "There is a sign here, but you are unable to read it." ) );
9664 }
9665 }
9666 if( m.has_graffiti_at( dest_loc ) ) {
9667 if( !u.has_trait( trait_ILLITERATE ) ) {
9668 add_msg( m_info, _( "Written here: %s" ), m.graffiti_at( dest_loc ) );
9669 } else {
9670 add_msg( m_info, _( "Something is written here, but you are unable to read it." ) );
9671 }
9672 }
9673 // TODO: Move the stuff below to a Character method so that NPCs can reuse it
9674 if( m.has_flag( "ROUGH", dest_loc ) && ( !u.in_vehicle ) && ( !u.is_mounted() ) ) {
9675 if( one_in( 5 ) && u.get_armor_bash( bodypart_id( "foot_l" ) ) < rng( 2, 5 ) ) {
9676 add_msg( m_bad, _( "You hurt your left foot on the %s!" ),
9677 m.has_flag_ter( "ROUGH", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9678 dest_loc ) );
9679 u.deal_damage( nullptr, bodypart_id( "foot_l" ), damage_instance( DT_CUT, 1 ) );
9680 }
9681 if( one_in( 5 ) && u.get_armor_bash( bodypart_id( "foot_r" ) ) < rng( 2, 5 ) ) {
9682 add_msg( m_bad, _( "You hurt your right foot on the %s!" ),
9683 m.has_flag_ter( "ROUGH", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9684 dest_loc ) );
9685 u.deal_damage( nullptr, bodypart_id( "foot_l" ), damage_instance( DT_CUT, 1 ) );
9686 }
9687 }
9688 ///\EFFECT_DEX increases chance of avoiding cuts on sharp terrain
9689 if( m.has_flag( "SHARP", dest_loc ) && !one_in( 3 ) && !x_in_y( 1 + u.dex_cur / 2.0, 40 ) &&
9690 ( !u.in_vehicle && !m.veh_at( dest_loc ) ) && ( !u.has_trait( trait_PARKOUR ) ||
9691 one_in( 4 ) ) && ( u.has_trait( trait_THICKSKIN ) ? !one_in( 8 ) : true ) ) {
9692 if( u.is_mounted() ) {
9693 add_msg( _( "Your %s gets cut!" ), u.mounted_creature->get_name() );
9694 u.mounted_creature->apply_damage( nullptr, bodypart_id( "torso" ), rng( 1, 10 ) );
9695 } else {
9696 const bodypart_id bp = u.get_random_body_part();
9697 if( u.deal_damage( nullptr, bp, damage_instance( DT_CUT, rng( 1, 10 ) ) ).total_damage() > 0 ) {
9698 //~ 1$s - bodypart name in accusative, 2$s is terrain name.
9699 add_msg( m_bad, _( "You cut your %1$s on the %2$s!" ),
9700 body_part_name_accusative( bp->token ),
9701 m.has_flag_ter( "SHARP", dest_loc ) ? m.tername( dest_loc ) : m.furnname(
9702 dest_loc ) );
9703 }
9704 }
9705 }
9706 if( m.has_flag( "UNSTABLE", dest_loc ) && !u.is_mounted() ) {
9707 u.add_effect( effect_bouldering, 1_turns, num_bp );
9708 } else if( u.has_effect( effect_bouldering ) ) {
9710 }
9711 if( m.has_flag_ter_or_furn( TFLAG_NO_SIGHT, dest_loc ) ) {
9712 u.add_effect( effect_no_sight, 1_turns, num_bp );
9713 } else if( u.has_effect( effect_no_sight ) ) {
9715 }
9716
9717 // If we moved out of the nonant, we need update our map data
9718 if( m.has_flag( "SWIMMABLE", dest_loc ) && u.has_effect( effect_onfire ) ) {
9719 add_msg( _( "The water puts out the flames!" ) );
9721 if( u.is_mounted() ) {
9722 monster *mon = u.mounted_creature.get();
9723 if( mon->has_effect( effect_onfire ) ) {
9725 }
9726 }
9727 }
9728
9729 if( monster *const mon_ptr = critter_at<monster>( dest_loc ) ) {
9730 // We displaced a monster. It's probably a bug if it wasn't a friendly mon...
9731 // Immobile monsters can't be displaced.
9732 monster &critter = *mon_ptr;
9733 // TODO: handling for ridden creatures other than players mount.
9734 if( !critter.has_effect( effect_ridden ) ) {
9735 if( u.is_mounted() ) {
9736 std::vector<tripoint> valid;
9737 for( const tripoint &jk : m.points_in_radius( critter.pos(), 1 ) ) {
9738 if( is_empty( jk ) ) {
9739 valid.push_back( jk );
9740 }
9741 }
9742 if( !valid.empty() ) {
9743 critter.move_to( random_entry( valid ) );
9744 add_msg( _( "You push the %s out of the way." ), critter.name() );
9745 } else {
9746 add_msg( _( "There is no room to push the %s out of the way." ), critter.name() );
9747 return u.pos().xy();
9748 }
9749 } else {
9750 critter.move_to( u.pos(), false,
9751 true ); // Force the movement even though the player is there right now.
9752 add_msg( _( "You displace the %s." ), critter.name() );
9753 }
9754 } else if( !u.has_effect( effect_riding ) ) {
9755 add_msg( _( "You cannot move the %s out of the way." ), critter.name() );
9756 return u.pos().xy();
9757 }
9758 }
9759
9760 // If the player is in a vehicle, unboard them from the current part
9761 if( u.in_vehicle ) {
9762 m.unboard_vehicle( u.pos() );
9763 }
9764 // Move the player
9765 // Start with z-level, to make it less likely that old functions (2D ones) freak out
9766 if( m.has_zlevels() && dest_loc.z != get_levz() ) {
9767 vertical_shift( dest_loc.z );
9768 }
9769
9770 if( u.is_hauling() && ( !m.can_put_items( dest_loc ) ||
9771 m.has_flag( TFLAG_DEEP_WATER, dest_loc ) ||
9772 vp1 ) ) {
9773 u.stop_hauling();
9774 }
9775 u.setpos( dest_loc );
9776 if( u.is_mounted() ) {
9777 monster *mon = u.mounted_creature.get();
9778 mon->setpos( dest_loc );
9779 mon->process_triggers();
9780 m.creature_in_field( *mon );
9781 }
9782 point submap_shift = update_map( u );
9783 // Important: don't use dest_loc after this line. `update_map` may have shifted the map
9784 // and dest_loc was not adjusted and therefore is still in the un-shifted system and probably wrong.
9785 // If you must use it you can calculate the position in the new, shifted system with
9786 // adjusted_pos = ( old_pos.x - submap_shift.x * SEEX, old_pos.y - submap_shift.y * SEEY, old_pos.z )
9787
9788 //Auto pulp or butcher and Auto foraging
9789 if( get_option<bool>( "AUTO_FEATURES" ) && mostseen == 0 && !u.is_mounted() ) {
9791
9792 const std::string forage_type = get_option<std::string>( "AUTO_FORAGING" );
9793 if( forage_type != "off" ) {
9794 const auto forage = [&]( const tripoint & pos ) {
9795 const auto &xter_t = m.ter( pos ).obj().examine;
9796 const auto &xfurn_t = m.furn( pos ).obj().examine;
9797 const bool forage_everything = forage_type == "both";
9798 const bool forage_bushes = forage_everything || forage_type == "bushes";
9799 const bool forage_trees = forage_everything || forage_type == "trees";
9800 if( xter_t == &iexamine::none ) {
9801 return;
9802 } else if( ( forage_bushes && xter_t == &iexamine::shrub_marloss ) ||
9803 ( forage_bushes && xter_t == &iexamine::shrub_wildveggies ) ||
9804 ( forage_bushes && xter_t == &iexamine::harvest_ter_nectar ) ||
9805 ( forage_trees && xter_t == &iexamine::tree_marloss ) ||
9806 ( forage_trees && xter_t == &iexamine::harvest_ter ) ||
9807 ( forage_trees && xter_t == &iexamine::harvest_ter_nectar )
9808 ) {
9809 xter_t( u, pos );
9810 } else if( ( forage_everything && xfurn_t == &iexamine::harvest_furn ) ||
9811 ( forage_everything && xfurn_t == &iexamine::harvest_furn_nectar )
9812 ) {
9813 xfurn_t( u, pos );
9814 }
9815 };
9816
9817 for( auto &elem : adjacentDir ) {
9818 forage( u.pos() + direction_XY( elem ) );
9819 }
9820 }
9821
9822 const std::string pulp_butcher = get_option<std::string>( "AUTO_PULP_BUTCHER" );
9823 if( pulp_butcher == "butcher" && u.max_quality( quality_id( "BUTCHER" ) ) > INT_MIN ) {
9824 std::vector<item *> corpses;
9825
9826 for( item &it : m.i_at( u.pos() ) ) {
9827 corpses.push_back( &it );
9828 }
9829
9830 if( !corpses.empty() ) {
9831 u.assign_activity( activity_id( "ACT_BUTCHER" ), 0, true );
9832 for( item *it : corpses ) {
9833 u.activity.targets.emplace_back( map_cursor( u.pos() ), it );
9834 }
9835 }
9836 } else if( pulp_butcher == "pulp" || pulp_butcher == "pulp_adjacent" ) {
9837 const auto pulp = [&]( const tripoint & pos ) {
9838 for( const auto &maybe_corpse : m.i_at( pos ) ) {
9839 if( maybe_corpse.is_corpse() && maybe_corpse.can_revive() &&
9840 !maybe_corpse.get_mtype()->bloodType().obj().has_acid ) {
9842 u.activity.placement = m.getabs( pos );
9843 u.activity.auto_resume = true;
9844 u.activity.str_values.push_back( "auto_pulp_no_acid" );
9845 return;
9846 }
9847 }
9848 };
9849
9850 if( pulp_butcher == "pulp_adjacent" ) {
9851 for( auto &elem : adjacentDir ) {
9852 pulp( u.pos() + direction_XY( elem ) );
9853 }
9854 } else {
9855 pulp( u.pos() );
9856 }
9857 }
9858 }
9859
9860 //Autopickup
9861 if( !u.is_mounted() && get_option<bool>( "AUTO_PICKUP" ) && !u.is_hauling() &&
9862 ( !get_option<bool>( "AUTO_PICKUP_SAFEMODE" ) || mostseen == 0 ) &&
9863 ( m.has_items( u.pos() ) || get_option<bool>( "AUTO_PICKUP_ADJACENT" ) ) ) {
9864 pickup::pick_up( u.pos(), -1 );
9865 }
9866
9867 // If the new tile is a boardable part, board it
9868 if( vp1.part_with_feature( "BOARDABLE", true ) && !u.is_mounted() ) {
9869 m.board_vehicle( u.pos(), &u );
9870 }
9871
9872 // Traps!
9873 // Try to detect.
9875 if( u.is_mounted() ) {
9877 } else {
9878 m.creature_on_trap( u );
9879 }
9880 // Drench the player if swimmable
9881 if( m.has_flag( "SWIMMABLE", u.pos() ) &&
9882 !( u.is_mounted() || ( u.in_vehicle && vp1->vehicle().can_float() ) ) ) {
9883 u.drench( 40, { { bp_foot_l, bp_foot_r, bp_leg_l, bp_leg_r } }, false );
9884 }
9885
9886 // List items here
9887 if( !m.has_flag( "SEALED", u.pos() ) ) {
9888 if( get_option<bool>( "NO_AUTO_PICKUP_ZONES_LIST_ITEMS" ) ||
9889 !check_zone( zone_type_id( "NO_AUTO_PICKUP" ), u.pos() ) ) {
9890 if( u.is_blind() && !m.i_at( u.pos() ).empty() ) {
9891 add_msg( _( "There's something here, but you can't see what it is." ) );
9892 } else if( m.has_items( u.pos() ) ) {
9893 std::vector<std::string> names;
9894 std::vector<size_t> counts;
9895 std::vector<item> items;
9896 for( auto &tmpitem : m.i_at( u.pos() ) ) {
9897
9898 std::string next_tname = tmpitem.tname();
9899 std::string next_dname = tmpitem.display_name();
9900 bool by_charges = tmpitem.count_by_charges();
9901 bool got_it = false;
9902 for( size_t i = 0; i < names.size(); ++i ) {
9903 if( by_charges && next_tname == names[i] ) {
9904 counts[i] += tmpitem.charges;
9905 got_it = true;
9906 break;
9907 } else if( next_dname == names[i] ) {
9908 counts[i] += 1;
9909 got_it = true;
9910 break;
9911 }
9912 }
9913 if( !got_it ) {
9914 if( by_charges ) {
9915 names.push_back( tmpitem.tname( tmpitem.charges ) );
9916 counts.push_back( tmpitem.charges );
9917 } else {
9918 names.push_back( tmpitem.display_name( 1 ) );
9919 counts.push_back( 1 );
9920 }
9921 items.push_back( tmpitem );
9922 }
9923 if( names.size() > 10 ) {
9924 break;
9925 }
9926 }
9927 for( size_t i = 0; i < names.size(); ++i ) {
9928 if( !items[i].count_by_charges() ) {
9929 names[i] = items[i].display_name( counts[i] );
9930 } else {
9931 names[i] = items[i].tname( counts[i] );
9932 }
9933 }
9934 int and_the_rest = 0;
9935 for( size_t i = 0; i < names.size(); ++i ) {
9936 //~ number of items: "<number> <item>"
9937 std::string fmt = vgettext( "%1$d %2$s", "%1$d %2$s", counts[i] );
9938 names[i] = string_format( fmt, counts[i], names[i] );
9939 // Skip the first two.
9940 if( i > 1 ) {
9941 and_the_rest += counts[i];
9942 }
9943 }
9944 if( names.size() == 1 ) {
9945 add_msg( _( "You see here %s." ), names[0] );
9946 } else if( names.size() == 2 ) {
9947 add_msg( _( "You see here %s and %s." ), names[0], names[1] );
9948 } else if( names.size() == 3 ) {
9949 add_msg( _( "You see here %s, %s, and %s." ), names[0], names[1], names[2] );
9950 } else if( and_the_rest < 7 ) {
9951 add_msg( vgettext( "You see here %s, %s and %d more item.",
9952 "You see here %s, %s and %d more items.",
9953 and_the_rest ),
9954 names[0], names[1], and_the_rest );
9955 } else {
9956 add_msg( _( "You see here %s and many more items." ), names[0] );
9957 }
9958 }
9959 }
9960 }
9961
9962 if( ( vp1.part_with_feature( "CONTROL_ANIMAL", true ) ||
9963 vp1.part_with_feature( "CONTROLS", true ) ) && u.in_vehicle && !u.is_mounted() ) {
9964 add_msg( _( "There are vehicle controls here." ) );
9965 if( !u.has_trait( trait_id( "WAYFARER" ) ) ) {
9966 add_msg( m_info, _( "%s to drive." ), press_x( ACTION_CONTROL_VEHICLE ) );
9967 }
9968 } else if( vp1.part_with_feature( "CONTROLS", true ) && u.in_vehicle &&
9969 u.is_mounted() ) {
9970 add_msg( _( "There are vehicle controls here but you cannot reach them whilst mounted." ) );
9971 }
9972 return submap_shift;
9973}
std::string body_part_name_accusative(body_part bp, int number)
Returns the matching accusative name of the body_part token, i.e.
Definition: bodypart.cpp:329
void drench(int saturation, const body_part_set &flags, bool ignore_waterproof)
Drenches the player with water, saturation is the percent gotten wet.
Definition: suffer.cpp:1755
bool is_hauling() const
Definition: character.cpp:9198
void stop_hauling()
Definition: character.cpp:9189
bodypart_id get_random_body_part(bool main=false) const
Definition: creature.cpp:1620
void vertical_shift(int z_after)
Actual z-level movement part of vertical_move.
Definition: game.cpp:11135
bool check_zone(const zone_type_id &type, const tripoint &where) const
Definition: game.cpp:6305
std::string furnname(const tripoint &p)
Definition: map.cpp:1464
bool has_flag_ter_or_furn(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2317
bool has_graffiti_at(const tripoint &p) const
Definition: map.cpp:7788
bool has_items(const tripoint &p) const
Checks for existence of items.
Definition: map.cpp:4750
const std::string & graffiti_at(const tripoint &p) const
Definition: map.cpp:7777
bool has_flag_ter(const std::string &flag, const tripoint &p) const
Definition: map.cpp:2307
bool can_put_items(const tripoint &p) const
Definition: map.cpp:2293
void setpos(const tripoint &p) override
Definition: monster.cpp:237
bool move_to(const tripoint &p, bool force=false, bool step_on_critter=false, float stagger_adjustment=1.0)
Attempt to move to p.
Definition: monmove.cpp:1501
void process_triggers()
Definition: monster.cpp:1192
cata::optional< std::string > get_label() const
std::vector< std::string > str_values
bool auto_resume
If true, the activity will be auto-resumed next time the player attempts an identical activity.
void search_surroundings()
Search surrounding squares for traps (and maybe other things in the future).
Definition: player.cpp:743
static const efftype_id effect_riding("riding")
static const trait_id trait_ILLITERATE("ILLITERATE")
static const efftype_id effect_bouldering("bouldering")
static const trait_id trait_PARKOUR("PARKOUR")
static const efftype_id effect_no_sight("no_sight")
static const trait_id trait_THICKSKIN("THICKSKIN")
static const efftype_id effect_onfire("onfire")
point direction_XY(const direction dir)
Definition: line.cpp:433
@ TFLAG_NO_SIGHT
Definition: mapdata.h:283
@ TFLAG_DEEP_WATER
Definition: mapdata.h:301
static std::map< nameFlags, std::vector< std::string > > names
Definition: name.cpp:18
const int INDEFINITELY_LONG
A number that represents the longest possible action.
void shrub_wildveggies(player &p, const tripoint &examp)
Definition: iexamine.cpp:3606
void shrub_marloss(player &p, const tripoint &examp)
Definition: iexamine.cpp:3571
void harvest_ter(player &p, const tripoint &examp)
Definition: iexamine.cpp:2043
void harvest_furn(player &p, const tripoint &examp)
Definition: iexamine.cpp:2022
void harvest_ter_nectar(player &p, const tripoint &examp)
Definition: iexamine.cpp:2031
void harvest_furn_nectar(player &p, const tripoint &examp)
Definition: iexamine.cpp:2013
void tree_marloss(player &p, const tripoint &examp)
Definition: iexamine.cpp:3585
string_id< zone_type > zone_type_id
Definition: type_id.h:192

References _, ACTION_CONTROL_VEHICLE, Character::activity, Creature::add_effect(), add_msg(), Character::assign_activity(), player_activity::auto_resume, map::board_vehicle(), body_part_name_accusative(), bp_foot_l, bp_foot_r, bp_leg_l, bp_leg_r, map::can_put_items(), check_zone(), map::creature_in_field(), map::creature_on_trap(), Character::deal_damage(), Character::dex_cur, direction_XY(), Character::drench(), DT_CUT, EAST, effect_bouldering, effect_no_sight, effect_onfire, effect_ridden, effect_riding, item_stack::empty(), map_data_common_t::examine, map::furn(), map::furnname(), Character::get_armor_bash(), optional_vpart_position::get_label(), get_levz(), Creature::get_random_body_part(), map::get_signage(), map::getabs(), map::graffiti_at(), iexamine::harvest_furn(), iexamine::harvest_furn_nectar(), iexamine::harvest_ter(), iexamine::harvest_ter_nectar(), Creature::has_effect(), map::has_flag(), map::has_flag_ter(), map::has_flag_ter_or_furn(), map::has_graffiti_at(), map::has_items(), Character::has_trait(), map::has_zlevels(), map::i_at(), Character::in_vehicle, calendar::INDEFINITELY_LONG, Character::is_blind(), is_empty(), Character::is_hauling(), Character::is_mounted(), m, m_bad, m_info, visitable< T >::max_quality(), mostseen, Character::mounted_creature, monster::move_to(), monster::name(), Name::names, iexamine::none(), NORTH, NORTHEAST, NORTHWEST, num_bp, int_id< T >::obj(), one_in(), optional_vpart_position::part_with_feature(), pickup::pick_up(), player_activity::placement, map::points_in_radius(), Character::pos(), monster::pos(), press_x(), monster::process_triggers(), random_entry(), Creature::remove_effect(), rng(), player::search_surroundings(), Character::setpos(), monster::setpos(), iexamine::shrub_marloss(), iexamine::shrub_wildveggies(), SOUTH, SOUTHEAST, SOUTHWEST, Character::stop_hauling(), player_activity::str_values, string_format(), player_activity::targets, map::ter(), map::tername(), TFLAG_DEEP_WATER, TFLAG_NO_SIGHT, trait_ILLITERATE, trait_PARKOUR, trait_THICKSKIN, iexamine::tree_marloss(), u, map::unboard_vehicle(), update_map(), map::veh_at(), vertical_shift(), vgettext(), WEST, x_in_y(), tripoint::xy(), and tripoint::z.

Referenced by place_player_overmap(), and walk_move().

◆ place_player_overmap()

void game::place_player_overmap ( const tripoint_abs_omt om_dest)

Definition at line 9975 of file game.cpp.

9976{
9977 // if player is teleporting around, they don't bring their horse with them
9978 if( u.is_mounted() ) {
9980 u.mounted_creature->remove_effect( effect_ridden );
9981 u.mounted_creature = nullptr;
9982 }
9983 // offload the active npcs.
9984 unload_npcs();
9985 for( monster &critter : all_monsters() ) {
9986 despawn_monster( critter );
9987 }
9988 if( u.in_vehicle ) {
9989 m.unboard_vehicle( u.pos() );
9990 }
9991
9993 const int minz = m.has_zlevels() ? -OVERMAP_DEPTH : get_levz();
9994 const int maxz = m.has_zlevels() ? OVERMAP_HEIGHT : get_levz();
9995 for( int z = minz; z <= maxz; z++ ) {
9996 m.clear_vehicle_list( z );
9997 }
9999 // offset because load_map expects the coordinates of the top left corner, but the
10000 // player will be centered in the middle of the map.
10001 // TODO: fix point types
10002 const tripoint map_sm_pos(
10003 project_to<coords::sm>( om_dest ).raw() + point( -HALF_MAPSIZE, -HALF_MAPSIZE ) );
10004 const tripoint player_pos( u.pos().xy(), map_sm_pos.z );
10005 load_map( map_sm_pos );
10006 load_npcs();
10007 m.spawn_monsters( true ); // Static monsters
10009 // update weather now as it could be different on the new location
10011 place_player( player_pos );
10012}
point place_player(const tripoint &dest)
Definition: game.cpp:9652
void unload_npcs()
Unloads all NPCs.
Definition: game.cpp:951
void update_overmap_seen()
Definition: game.cpp:11313
level_cache & access_cache(int zlev)
Definition: map.cpp:8659
void clear_vehicle_list(int zlev)
Definition: map.cpp:327
void clear_vehicle_cache()
Definition: map.cpp:309
std::bitset< MAPSIZE_X *MAPSIZE_Y > map_memory_seen_cache
Definition: map.h:352

References map::access_cache(), all_monsters(), map::clear_vehicle_cache(), map::clear_vehicle_list(), despawn_monster(), effect_ridden, effect_riding, get_levz(), get_weather, HALF_MAPSIZE, map::has_zlevels(), Character::in_vehicle, Character::is_mounted(), load_map(), load_npcs(), m, level_cache::map_memory_seen_cache, Character::mounted_creature, weather_manager::nextweather, OVERMAP_DEPTH, OVERMAP_HEIGHT, place_player(), Character::pos(), Creature::remove_effect(), map::spawn_monsters(), calendar::turn, u, map::unboard_vehicle(), unload_npcs(), update_overmap_seen(), tripoint::xy(), and tripoint::z.

◆ place_vehicle_nearby()

vehicle * game::place_vehicle_nearby ( const vproto_id id,
const point_abs_omt origin,
int  min_distance,
int  max_distance,
const std::vector< std::string > &  omt_search_types = {} 
)
private

Definition at line 847 of file game.cpp.

850{
851 std::vector<std::string> search_types = omt_search_types;
852 if( search_types.empty() ) {
853 vehicle veh( id );
854 if( veh.can_float() ) {
855 search_types.push_back( "river" );
856 search_types.push_back( "lake" );
857 } else {
858 search_types.push_back( "field" );
859 search_types.push_back( "road" );
860 }
861 }
862 for( const std::string &search_type : search_types ) {
863 omt_find_params find_params;
864 find_params.must_see = false;
865 find_params.cant_see = false;
866 find_params.types.emplace_back( search_type, ot_match_type::type );
867 // find nearest road
868 find_params.min_distance = min_distance;
869 find_params.search_range = max_distance;
870 // if player spawns underground, park their car on the surface.
871 const tripoint_abs_omt omt_origin( origin, 0 );
872 for( const tripoint_abs_omt &goal : overmap_buffer.find_all( omt_origin, find_params ) ) {
873 // try place vehicle there.
874 tinymap target_map;
875 target_map.load( project_to<coords::sm>( goal ), false );
876 const tripoint tinymap_center( SEEX, SEEY, goal.z() );
877 static constexpr std::array<units::angle, 4> angles = {{
878 0_degrees, 90_degrees, 180_degrees, 270_degrees
879 }
880 };
881 vehicle *veh = target_map.add_vehicle(
882 id, tinymap_center, random_entry( angles ), rng( 50, 80 ), 0, false );
883 if( veh ) {
884 tripoint abs_local = m.getlocal( target_map.getabs( tinymap_center ) );
885 veh->sm_pos = ms_to_sm_remain( abs_local );
886 veh->pos = abs_local.xy();
888 veh->tracking_on = true;
889 target_map.save();
890 return veh;
891 }
892 }
893 }
894 return nullptr;
895}
void save()
Add currently loaded submaps (in grid) to the mapbuffer.
Definition: map.cpp:6576
vehicle * add_vehicle(const vgroup_id &type, const tripoint &p, units::angle dir, int init_veh_fuel=-1, int init_veh_status=-1, bool merge_wrecks=true)
Definition: mapgen.cpp:5600
void add_vehicle(vehicle *veh)
Add the vehicle to be tracked in the overmap.
std::vector< tripoint_abs_omt > find_all(const tripoint_abs_omt &origin, const omt_find_params &params)
Find all places with the specific overmap terrain type.
Definition: map.h:2087
point pos
Position of the vehicle inside the submap that contains the vehicle.
Definition: vehicle.h:1916
tripoint sm_pos
Submap coordinates of the currently loaded submap (see game::m) that contains this vehicle.
Definition: vehicle.h:1901
bool tracking_on
Definition: vehicle.h:1991
point ms_to_sm_remain(int &x, int &y)
static constexpr int SEEY
Standard arguments for finding overmap terrain.
std::vector< std::pair< std::string, ot_match_type > > types

References map::add_vehicle(), overmapbuffer::add_vehicle(), vehicle::can_float(), omt_find_params::cant_see, overmapbuffer::find_all(), map::getabs(), map::getlocal(), map::load(), m, omt_find_params::min_distance, ms_to_sm_remain(), omt_find_params::must_see, overmap_buffer, vehicle::pos, random_entry(), rng(), map::save(), omt_find_params::search_range, SEEX, SEEY, vehicle::sm_pos, vehicle::tracking_on, type, omt_find_params::types, and tripoint::xy().

Referenced by start_game().

◆ pre_print_all_tile_info()

void game::pre_print_all_tile_info ( const tripoint lp,
const catacurses::window w_info,
int &  line,
int  last_line,
const visibility_variables cache 
)

Definition at line 6847 of file game.cpp.

6850{
6851 // get global area info according to look_around caret position
6852 // TODO: fix point types
6854 lp ) ) ) );
6855 // we only need the area name and then pass it to print_all_tile_info() function below
6856 const std::string area_name = cur_ter_m->get_name();
6857 print_all_tile_info( lp, w_info, area_name, 1, first_line, last_line, cache );
6858}
void print_all_tile_info(const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line, int last_line, const visibility_variables &cache)
Definition: game.cpp:6027
point ms_to_omt_copy(const point &p)
coords::coord_point< tripoint, coords::origin::abs, coords::omt > tripoint_abs_omt
Definition: coordinates.h:493
std::string get_name() const
Definition: omdata.h:205

References oter_t::get_name(), map::getabs(), m, ms_to_omt_copy(), overmap_buffer, print_all_tile_info(), and overmapbuffer::ter().

Referenced by look_around().

◆ print_all_tile_info()

void game::print_all_tile_info ( const tripoint lp,
const catacurses::window w_look,
const std::string &  area_name,
int  column,
int &  line,
int  last_line,
const visibility_variables cache 
)

Definition at line 6027 of file game.cpp.

6032{
6033 visibility_type visibility = VIS_HIDDEN;
6034 const bool inbounds = m.inbounds( lp );
6035 if( inbounds ) {
6036 visibility = m.get_visibility( m.apparent_light_at( lp, cache ), cache );
6037 }
6038 const Creature *creature = critter_at( lp, true );
6039 switch( visibility ) {
6040 case VIS_CLEAR: {
6041 const optional_vpart_position vp = m.veh_at( lp );
6042 print_terrain_info( lp, w_look, area_name, column, line );
6043 print_fields_info( lp, w_look, column, line );
6044 print_trap_info( lp, w_look, column, line );
6045 print_creature_info( creature, w_look, column, line, last_line );
6046 print_vehicle_info( veh_pointer_or_null( vp ), vp ? vp->part_index() : -1, w_look, column, line,
6047 last_line );
6048 print_items_info( lp, w_look, column, line, last_line );
6049 print_graffiti_info( lp, w_look, column, line, last_line );
6050 }
6051 break;
6052 case VIS_BOOMER:
6053 case VIS_BOOMER_DARK:
6054 case VIS_DARK:
6055 case VIS_LIT:
6056 case VIS_HIDDEN:
6057 print_visibility_info( w_look, column, line, visibility );
6058
6059 if( creature != nullptr ) {
6060 std::vector<std::string> buf;
6061 if( u.sees_with_infrared( *creature ) ) {
6062 creature->describe_infrared( buf );
6063 } else if( u.sees_with_specials( *creature ) ) {
6064 creature->describe_specials( buf );
6065 }
6066 for( const std::string &s : buf ) {
6067 mvwprintw( w_look, point( 1, ++line ), s );
6068 }
6069 }
6070 break;
6071 }
6072 if( !inbounds ) {
6073 return;
6074 }
6075 auto this_sound = sounds::sound_at( lp );
6076 if( !this_sound.empty() ) {
6077 mvwprintw( w_look, point( 1, ++line ), _( "You heard %s from here." ), this_sound );
6078 } else {
6079 // Check other z-levels
6080 tripoint tmp = lp;
6081 for( tmp.z = -OVERMAP_DEPTH; tmp.z <= OVERMAP_HEIGHT; tmp.z++ ) {
6082 if( tmp.z == lp.z ) {
6083 continue;
6084 }
6085
6086 auto zlev_sound = sounds::sound_at( tmp );
6087 if( !zlev_sound.empty() ) {
6088 mvwprintw( w_look, point( 1, ++line ), tmp.z > lp.z ?
6089 _( "You heard %s from above." ) : _( "You heard %s from below." ), zlev_sound );
6090 }
6091 }
6092 }
6093}
bool sees_with_specials(const Creature &critter) const
Definition: character.cpp:6440
bool sees_with_infrared(const Creature &critter) const
Check whether the this player can see the other creature with infrared.
void print_fields_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line)
Definition: game.cpp:6197
void print_terrain_info(const tripoint &lp, const catacurses::window &w_look, const std::string &area_name, int column, int &line)
Definition: game.cpp:6124
void print_graffiti_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6289
void print_creature_info(const Creature *creature, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6234
void print_vehicle_info(const vehicle *veh, int veh_part, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6243
void print_items_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line, int last_line)
Definition: game.cpp:6252
void print_visibility_info(const catacurses::window &w_look, int column, int &line, visibility_type visibility)
Definition: game.cpp:6095
void print_trap_info(const tripoint &lp, const catacurses::window &w_look, int column, int &line)
Definition: game.cpp:6215
void line(map *m, const ter_id &type, const point &p1, const point &p2)
Definition: mapgen.cpp:6455
std::string sound_at(const tripoint &location)
Definition: sounds.cpp:605

References _, map::apparent_light_at(), creature, critter_at(), map::get_visibility(), map::inbounds(), line(), m, catacurses::mvwprintw(), OVERMAP_DEPTH, OVERMAP_HEIGHT, print_creature_info(), print_fields_info(), print_graffiti_info(), print_items_info(), print_terrain_info(), print_trap_info(), print_vehicle_info(), print_visibility_info(), Character::sees_with_infrared(), Character::sees_with_specials(), sounds::sound_at(), u, map::veh_at(), veh_pointer_or_null(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, VIS_LIT, and tripoint::z.

Referenced by pre_print_all_tile_info().

◆ print_creature_info()

void game::print_creature_info ( const Creature creature,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6234 of file game.cpp.

6236{
6237 int vLines = last_line - line;
6238 if( creature != nullptr && ( u.sees( *creature ) || creature == &u ) ) {
6239 line = creature->print_info( w_look, ++line, vLines, column );
6240 }
6241}

References creature, line(), Character::sees(), and u.

Referenced by print_all_tile_info().

◆ print_fields_info()

void game::print_fields_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line 
)
private

Definition at line 6197 of file game.cpp.

6199{
6200 const field &tmpfield = m.field_at( lp );
6201 for( auto &fld : tmpfield ) {
6202 const field_entry &cur = fld.second;
6203 if( fld.first.obj().has_fire && ( m.has_flag( TFLAG_FIRE_CONTAINER, lp ) ||
6204 m.ter( lp ) == t_pit_shallow || m.ter( lp ) == t_pit ) ) {
6205 const int max_width = getmaxx( w_look ) - column - 2;
6206 int lines = fold_and_print( w_look, point( column, ++line ), max_width, cur.color(),
6207 get_fire_fuel_string( lp ) ) - 1;
6208 line += lines;
6209 } else {
6210 mvwprintz( w_look, point( column, ++line ), cur.color(), cur.name() );
6211 }
6212 }
6213}
An active or passive effect existing on a tile.
Definition: field.h:20
nc_color color() const
Definition: field.cpp:94
std::string name() const
Definition: field.h:84
A variable sized collection of field entries on a given map square.
Definition: field.h:131
ter_id t_pit_shallow
Definition: mapdata.cpp:625
ter_id t_pit
Definition: mapdata.cpp:625

References field_entry::color(), map::field_at(), fold_and_print(), get_fire_fuel_string(), catacurses::getmaxx(), map::has_flag(), line(), m, mvwprintz(), field_entry::name(), t_pit, t_pit_shallow, map::ter(), and TFLAG_FIRE_CONTAINER.

Referenced by print_all_tile_info().

◆ print_graffiti_info()

void game::print_graffiti_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6289 of file game.cpp.

6292{
6293 if( line > last_line ) {
6294 return;
6295 }
6296
6297 const int max_width = getmaxx( w_look ) - column - 2;
6298 if( m.has_graffiti_at( lp ) ) {
6299 fold_and_print( w_look, point( column, ++line ), max_width, c_light_gray,
6300 m.ter( lp ) == t_grave_new ? _( "Graffiti: %s" ) : _( "Inscription: %s" ),
6301 m.graffiti_at( lp ) );
6302 }
6303}
ter_id t_grave_new
Definition: mapdata.cpp:625

References _, c_light_gray, fold_and_print(), catacurses::getmaxx(), map::graffiti_at(), map::has_graffiti_at(), line(), m, t_grave_new, and map::ter().

Referenced by print_all_tile_info().

◆ print_items_info()

void game::print_items_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6252 of file game.cpp.

6255{
6256 if( !m.sees_some_items( lp, u ) ) {
6257 return;
6258 } else if( m.has_flag( "CONTAINER", lp ) && !m.could_see_items( lp, u ) ) {
6259 mvwprintw( w_look, point( column, ++line ), _( "You cannot see what is inside of it." ) );
6260 } else if( u.has_effect( effect_blind ) || u.worn_with_flag( "BLIND" ) ) {
6261 mvwprintz( w_look, point( column, ++line ), c_yellow,
6262 _( "There's something there, but you can't see what it is." ) );
6263 return;
6264 } else {
6265 std::map<std::string, int> item_names;
6266 for( auto &item : m.i_at( lp ) ) {
6267 ++item_names[item.tname()];
6268 }
6269
6270 const int max_width = getmaxx( w_look ) - column - 1;
6271 for( auto it = item_names.begin(); it != item_names.end(); ++it ) {
6272 // last line but not last item
6273 if( line + 1 >= last_line && std::next( it ) != item_names.end() ) {
6274 mvwprintz( w_look, point( column, ++line ), c_yellow, _( "More items here…" ) );
6275 break;
6276 }
6277
6278 if( it->second > 1 ) {
6279 trim_and_print( w_look, point( column, ++line ), max_width, c_white,
6280 pgettext( "%s is the name of the item. %d is the quantity of that item.", "%s [%d]" ),
6281 it->first.c_str(), it->second );
6282 } else {
6283 trim_and_print( w_look, point( column, ++line ), max_width, c_white, it->first );
6284 }
6285 }
6286 }
6287}
bool could_see_items(const tripoint &p, const Creature &who) const
Check if the creature could see items at p if there were any items.
Definition: map.cpp:4726
static const efftype_id effect_blind("blind")

References _, c_white, c_yellow, map::could_see_items(), effect_blind, catacurses::getmaxx(), Creature::has_effect(), map::has_flag(), map::i_at(), line(), m, catacurses::mvwprintw(), mvwprintz(), pgettext(), map::sees_some_items(), item::tname(), trim_and_print(), u, and Character::worn_with_flag().

Referenced by print_all_tile_info().

◆ print_terrain_info()

void game::print_terrain_info ( const tripoint lp,
const catacurses::window w_look,
const std::string &  area_name,
int  column,
int &  line 
)
private

Definition at line 6124 of file game.cpp.

6127{
6128 const int max_width = getmaxx( w_look ) - column - 1;
6129 int lines;
6130
6131 const auto fmt_tile_info = []( const tripoint & lp ) {
6132 map &here = get_map();
6133 std::string ret;
6134 if( debug_mode ) {
6135 ret = string_format( "%s %s", lp.to_string(), here.ter( lp )->id );
6136 if( here.has_furn( lp ) ) {
6137 ret += "; " + here.furn( lp )->id.str();
6138 }
6139 } else {
6140 ret = here.tername( lp );
6141 if( here.has_furn( lp ) ) {
6142 ret += "; " + here.furnname( lp );
6143 }
6144 }
6145 return ret;
6146 };
6147
6148 std::string tile = string_format( "(%s) %s", area_name, fmt_tile_info( lp ) );
6149
6150 if( m.impassable( lp ) ) {
6151 lines = fold_and_print( w_look, point( column, line ), max_width, c_light_gray,
6152 _( "%s; Impassable" ),
6153 tile );
6154 } else {
6155 lines = fold_and_print( w_look, point( column, line ), max_width, c_light_gray,
6156 _( "%s; Movement cost %d" ),
6157 tile, m.move_cost( lp ) * 50 );
6158
6159 const auto ll = get_light_level( std::max( 1.0,
6160 LIGHT_AMBIENT_LIT - m.ambient_light_at( lp ) + 1.0 ) );
6161 mvwprintw( w_look, point( column, ++lines ), _( "Lighting: " ) );
6162 wprintz( w_look, ll.second, ll.first );
6163 }
6164
6165 std::string signage = m.get_signage( lp );
6166 if( !signage.empty() ) {
6167 trim_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6168 // NOLINTNEXTLINE(cata-text-style): the question mark does not end a sentence
6169 u.has_trait( trait_ILLITERATE ) ? _( "Sign: ???" ) : _( "Sign: %s" ), signage );
6170 }
6171
6172 if( m.has_zlevels() && lp.z > -OVERMAP_DEPTH && !m.has_floor( lp ) ) {
6173 // Print info about stuff below
6174 tripoint below( lp.xy(), lp.z - 1 );
6175 std::string tile_below = fmt_tile_info( below );
6176
6177 if( !m.has_floor_or_support( lp ) ) {
6178 fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6179 _( "Below: %s; No support" ),
6180 tile_below );
6181 } else {
6182 fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6183 _( "Below: %s; Walkable" ),
6184 tile_below );
6185 }
6186 }
6187
6188 int map_features = fold_and_print( w_look, point( column, ++lines ), max_width, c_dark_gray,
6189 m.features( lp ) );
6190 fold_and_print( w_look, point( column, ++lines ), max_width, c_light_gray, _( "Coverage: %d%%" ),
6191 m.coverage( lp ) );
6192 if( line < lines ) {
6193 line = lines + map_features - 1;
6194 }
6195}
Manage and cache data about a part of the map.
Definition: map.h:385
bool has_floor_or_support(const tripoint &p) const
Definition: map.cpp:2034
float ambient_light_at(const tripoint &p) const
Definition: lightmap.cpp:617
std::string features(const tripoint &p)
Definition: map.cpp:1709
int coverage(const tripoint &p) const
Returns coverage value of the tile.
Definition: map.cpp:6226
const std::string & str() const
Returns the identifier as plain std::string.
Definition: string_id.h:255
static constexpr float LIGHT_AMBIENT_LIT
Definition: lightmap.h:18
std::pair< std::string, nc_color > get_light_level(const float light)
Definition: output.cpp:1621
furn_str_id id
Definition: mapdata.h:490
ter_str_id id
Definition: mapdata.h:458

References _, map::ambient_light_at(), c_dark_gray, c_light_gray, map::coverage(), debug_mode, map::features(), fold_and_print(), map::furn(), map::furnname(), get_light_level(), get_map, map::get_signage(), catacurses::getmaxx(), map::has_floor(), map::has_floor_or_support(), map::has_furn(), Character::has_trait(), map::has_zlevels(), ter_t::id, furn_t::id, map::impassable(), LIGHT_AMBIENT_LIT, line(), m, map::move_cost(), catacurses::mvwprintw(), OVERMAP_DEPTH, cata::hash64_detail::ret, string_id< T >::str(), string_format(), map::ter(), map::tername(), tripoint::to_string(), trait_ILLITERATE, trim_and_print(), u, wprintz(), tripoint::xy(), and tripoint::z.

Referenced by print_all_tile_info().

◆ print_trap_info()

void game::print_trap_info ( const tripoint lp,
const catacurses::window w_look,
int  column,
int &  line 
)
private

Definition at line 6215 of file game.cpp.

6217{
6218 const trap &tr = m.tr_at( lp );
6219 if( tr.can_see( lp, u ) ) {
6220 partial_con *pc = m.partial_con_at( lp );
6221 std::string tr_name;
6222 if( pc && tr.loadid == tr_unfinished_construction ) {
6223 const construction &built = pc->id.obj();
6224 tr_name = string_format( _( "Unfinished task: %s, %d%% complete" ), built.description,
6225 pc->counter / 100000 );
6226 } else {
6227 tr_name = tr.name();
6228 }
6229
6230 mvwprintz( w_look, point( column, ++line ), tr.color, tr_name );
6231 }
6232}
partial_con * partial_con_at(const tripoint &p)
Definition: map.cpp:5131
static const trap_str_id tr_unfinished_construction("tr_unfinished_construction")
std::string description
Definition: construction.h:51
construction_id id
Definition: construction.h:33
nc_color color
Definition: trap.h:93

References _, trap::can_see(), trap::color, partial_con::counter, construction::description, partial_con::id, line(), trap::loadid, m, mvwprintz(), trap::name(), int_id< T >::obj(), map::partial_con_at(), string_format(), map::tr_at(), tr_unfinished_construction, and u.

Referenced by print_all_tile_info().

◆ print_vehicle_info()

void game::print_vehicle_info ( const vehicle veh,
int  veh_part,
const catacurses::window w_look,
int  column,
int &  line,
int  last_line 
)
private

Definition at line 6243 of file game.cpp.

6245{
6246 if( veh ) {
6247 mvwprintw( w_look, point( column, ++line ), _( "There is a %s there. Parts:" ), veh->name );
6248 line = veh->print_part_list( w_look, ++line, last_line, getmaxx( w_look ), veh_part );
6249 }
6250}
int print_part_list(const catacurses::window &win, int y1, int max_y, int width, int p, int hl=-1, bool detail=false) const
Prints a list of all parts to the screen inside of a boxed window, possibly highlighting a selected o...

References _, catacurses::getmaxx(), line(), catacurses::mvwprintw(), vehicle::name, and vehicle::print_part_list().

Referenced by print_all_tile_info().

◆ print_visibility_info()

void game::print_visibility_info ( const catacurses::window w_look,
int  column,
int &  line,
visibility_type  visibility 
)
private

Definition at line 6095 of file game.cpp.

6097{
6098 const char *visibility_message = nullptr;
6099 switch( visibility ) {
6100 case VIS_CLEAR:
6101 visibility_message = _( "Clearly visible." );
6102 break;
6103 case VIS_BOOMER:
6104 visibility_message = _( "A bright pink blur." );
6105 break;
6106 case VIS_BOOMER_DARK:
6107 visibility_message = _( "A pink blur." );
6108 break;
6109 case VIS_DARK:
6110 visibility_message = _( "Darkness." );
6111 break;
6112 case VIS_LIT:
6113 visibility_message = _( "Bright light." );
6114 break;
6115 case VIS_HIDDEN:
6116 visibility_message = _( "Unseen." );
6117 break;
6118 }
6119
6120 mvwprintw( w_look, point( line, column ), visibility_message );
6121 line += 2;
6122}

References _, line(), catacurses::mvwprintw(), VIS_BOOMER, VIS_BOOMER_DARK, VIS_CLEAR, VIS_DARK, VIS_HIDDEN, and VIS_LIT.

Referenced by print_all_tile_info().

◆ process_activity()

void game::process_activity ( )
private

Definition at line 1742 of file game.cpp.

1743{
1744 if( !u.activity ) {
1745 return;
1746 }
1747
1748 while( u.moves > 0 && u.activity ) {
1749 u.activity.do_turn( u );
1750 }
1751}
void do_turn(player &p)
Performs the activity for a single turn.

References Character::activity, player_activity::do_turn(), Creature::moves, and u.

Referenced by do_turn().

◆ process_artifact()

void game::process_artifact ( item it,
player p 
)

Definition at line 11886 of file game.cpp.

11887{
11888 const bool worn = p.is_worn( it );
11889 const bool wielded = ( &it == &p.weapon );
11890 std::vector<art_effect_passive> effects = it.type->artifact->effects_carried;
11891 if( worn ) {
11892 const std::vector<art_effect_passive> &ew = it.type->artifact->effects_worn;
11893 effects.insert( effects.end(), ew.begin(), ew.end() );
11894 }
11895 if( wielded ) {
11896 const std::vector<art_effect_passive> &ew = it.type->artifact->effects_wielded;
11897 effects.insert( effects.end(), ew.begin(), ew.end() );
11898 }
11899
11900 if( it.is_tool() ) {
11901 // Recharge it if necessary
11902 if( it.ammo_remaining() < it.ammo_capacity() && calendar::once_every( 1_minutes ) ) {
11903 //Before incrementing charge, check that any extra requirements are met
11904 if( check_art_charge_req( it ) ) {
11905 switch( it.type->artifact->charge_type ) {
11906 case ARTC_NULL:
11907 case NUM_ARTCS:
11908 break; // dummy entries
11909 case ARTC_TIME:
11910 // Once per hour
11911 if( calendar::once_every( 1_hours ) ) {
11912 it.charges++;
11913 }
11914 break;
11915 case ARTC_SOLAR:
11916 if( calendar::once_every( 10_minutes ) &&
11917 is_in_sunlight( p.pos() ) ) {
11918 it.charges++;
11919 }
11920 break;
11921 // Artifacts can inflict pain even on Deadened folks.
11922 // Some weird Lovecraftian thing. ;P
11923 // (So DON'T route them through mod_pain!)
11924 case ARTC_PAIN:
11925 if( calendar::once_every( 1_minutes ) ) {
11926 add_msg( m_bad, _( "You suddenly feel sharp pain for no reason." ) );
11927 p.mod_pain_noresist( 3 * rng( 1, 3 ) );
11928 it.charges++;
11929 }
11930 break;
11931 case ARTC_HP:
11932 if( calendar::once_every( 1_minutes ) ) {
11933 add_msg( m_bad, _( "You feel your body decaying." ) );
11934 p.hurtall( 1, nullptr );
11935 it.charges++;
11936 }
11937 break;
11938 case ARTC_FATIGUE:
11939 if( calendar::once_every( 1_minutes ) ) {
11940 add_msg( m_bad, _( "You feel fatigue seeping into your body." ) );
11941 u.mod_fatigue( 3 * rng( 1, 3 ) );
11942 u.mod_stamina( -90 * rng( 1, 3 ) * rng( 1, 3 ) * rng( 2, 3 ) );
11943 it.charges++;
11944 }
11945 break;
11946 // Portals are energetic enough to charge the item.
11947 // Tears in reality are consumed too, but can't charge it.
11948 case ARTC_PORTAL:
11949 for( const tripoint &dest : m.points_in_radius( p.pos(), 1 ) ) {
11950 m.remove_field( dest, fd_fatigue );
11951 if( m.tr_at( dest ).loadid == tr_portal ) {
11952 add_msg( m_good, _( "The portal collapses!" ) );
11953 m.remove_trap( dest );
11954 it.charges++;
11955 break;
11956 }
11957 }
11958 break;
11959 }
11960 }
11961 }
11962 }
11963
11964 for( const art_effect_passive &i : effects ) {
11965 switch( i ) {
11966 case AEP_STR_UP:
11967 p.mod_str_bonus( +4 );
11968 break;
11969 case AEP_DEX_UP:
11970 p.mod_dex_bonus( +4 );
11971 break;
11972 case AEP_PER_UP:
11973 p.mod_per_bonus( +4 );
11974 break;
11975 case AEP_INT_UP:
11976 p.mod_int_bonus( +4 );
11977 break;
11978 case AEP_ALL_UP:
11979 p.mod_str_bonus( +2 );
11980 p.mod_dex_bonus( +2 );
11981 p.mod_per_bonus( +2 );
11982 p.mod_int_bonus( +2 );
11983 break;
11984 case AEP_SPEED_UP:
11985 // Handled in player::current_speed()
11986 break;
11987
11988 case AEP_PBLUE:
11989 if( p.get_rad() > 0 ) {
11990 p.mod_rad( -1 );
11991 }
11992 break;
11993
11994 case AEP_SMOKE:
11995 if( one_in( 10 ) ) {
11996 tripoint pt( p.posx() + rng( -1, 1 ),
11997 p.posy() + rng( -1, 1 ),
11998 p.posz() );
11999 m.add_field( pt, fd_smoke, rng( 1, 3 ) );
12000 }
12001 break;
12002
12003 case AEP_SNAKES:
12004 break; // Handled in player::hit()
12005
12006 case AEP_EXTINGUISH:
12007 for( const tripoint &dest : m.points_in_radius( p.pos(), 1 ) ) {
12008 m.mod_field_age( dest, fd_fire, -1_turns );
12009 }
12010 break;
12011
12012 case AEP_FUN:
12013 //Bonus fluctuates, wavering between 0 and 30-ish - usually around 12
12014 p.add_morale( MORALE_FEELING_GOOD, rng( 1, 2 ) * rng( 2, 3 ), 0, 3_turns, 0_turns, false );
12015 break;
12016
12017 case AEP_HUNGER:
12018 if( one_in( 100 ) ) {
12019 p.mod_stored_kcal( -10 );
12020 }
12021 break;
12022
12023 case AEP_THIRST:
12024 if( one_in( 120 ) ) {
12025 p.mod_thirst( 1 );
12026 }
12027 break;
12028
12029 case AEP_EVIL:
12030 if( one_in( 150 ) ) { // Once every 15 minutes, on average
12031 p.add_effect( effect_evil, 30_minutes );
12032 if( it.is_armor() ) {
12033 if( !worn ) {
12034 add_msg( _( "You have an urge to wear the %s." ),
12035 it.tname() );
12036 }
12037 } else if( !wielded ) {
12038 add_msg( _( "You have an urge to wield the %s." ),
12039 it.tname() );
12040 }
12041 }
12042 break;
12043
12044 case AEP_SCHIZO:
12045 break; // Handled in player::suffer()
12046
12047 case AEP_RADIOACTIVE:
12048 if( one_in( 4 ) ) {
12049 p.irradiate( 1.0f );
12050 }
12051 break;
12052
12053 case AEP_STR_DOWN:
12054 p.mod_str_bonus( -3 );
12055 break;
12056
12057 case AEP_DEX_DOWN:
12058 p.mod_dex_bonus( -3 );
12059 break;
12060
12061 case AEP_PER_DOWN:
12062 p.mod_per_bonus( -3 );
12063 break;
12064
12065 case AEP_INT_DOWN:
12066 p.mod_int_bonus( -3 );
12067 break;
12068
12069 case AEP_ALL_DOWN:
12070 p.mod_str_bonus( -2 );
12071 p.mod_dex_bonus( -2 );
12072 p.mod_per_bonus( -2 );
12073 p.mod_int_bonus( -2 );
12074 break;
12075
12076 case AEP_SPEED_DOWN:
12077 break; // Handled in player::current_speed()
12078
12079 default:
12080 //Suppress warnings
12081 break;
12082 }
12083 }
12084 // Recalculate, as it might have changed (by mod_*_bonus above)
12085 p.str_cur = p.get_str();
12086 p.int_cur = p.get_int();
12087 p.dex_cur = p.get_dex();
12088 p.per_cur = p.get_per();
12089}
@ ARTC_PORTAL
Definition: artifact.h:69
@ ARTC_FATIGUE
Definition: artifact.h:68
@ ARTC_NULL
Definition: artifact.h:63
@ ARTC_SOLAR
Definition: artifact.h:65
@ NUM_ARTCS
Definition: artifact.h:70
@ ARTC_HP
Definition: artifact.h:67
@ ARTC_TIME
Definition: artifact.h:64
@ ARTC_PAIN
Definition: artifact.h:66
virtual void mod_per_bonus(int nper)
Definition: character.cpp:4200
virtual void mod_dex_bonus(int ndex)
Definition: character.cpp:4195
int str_cur
Definition: character.h:246
void mod_rad(int mod)
Definition: character.cpp:7200
virtual int get_dex() const
Definition: character.cpp:4084
virtual void mod_stored_kcal(int nkcal)
Modifiers for need values exclusive to characters.
Definition: character.cpp:4315
bool is_worn(const item &thing) const
Definition: character.h:1084
virtual int get_int() const
Definition: character.cpp:4092
virtual void mod_fatigue(int nfatigue)
Definition: character.cpp:4446
virtual void mod_str_bonus(int nstr)
Definition: character.cpp:4190
int int_cur
Definition: character.h:248
int get_rad() const
Definition: character.cpp:7190
void add_morale(const morale_type &type, int bonus, int max_bonus=0, const time_duration &duration=1_hours, const time_duration &decay_start=30_minutes, bool capped=false, const itype *item_type=nullptr)
Definition: character.cpp:9105
virtual int get_per() const
Definition: character.cpp:4088
void mod_stamina(int mod)
Definition: character.cpp:7227
void hurtall(int dam, Creature *source, bool disturb=true)
Hurts all body parts for dam, no armor reduction.
Definition: character.cpp:8671
bool irradiate(float rads, bool bypass=false)
Handles mitigation and application of radiation.
Definition: suffer.cpp:1532
virtual void mod_int_bonus(int nint)
Definition: character.cpp:4205
virtual void mod_pain_noresist(int npain)
Definition: creature.cpp:1352
bool is_in_sunlight(const tripoint &p)
Returns true if p is outdoors and it is sunny.
Definition: game.cpp:5167
int ammo_remaining() const
Quantity of ammunition currently loaded in tool, gun or auxiliary gunmod.
Definition: item.cpp:7220
bool is_tool() const
Definition: item.cpp:6797
int ammo_capacity() const
Maximum quantity of ammunition loadable for tool, gun or auxiliary gunmod.
Definition: item.cpp:7247
int charges
Definition: item.h:2195
bool is_armor() const
Definition: item.cpp:6548
const itype * type
Definition: item.h:2156
bool add_field(const tripoint &p, const field_type_id &type_id, int intensity=INT_MAX, const time_duration &age=0_turns, bool hit_player=true)
Add field entry at point, or set intensity if present.
Definition: map.cpp:5386
time_duration mod_field_age(const tripoint &p, const field_type_id &type, const time_duration &offset)
Increment/decrement age of field entry at point.
Definition: map.cpp:5306
void remove_trap(const tripoint &p)
Definition: map.cpp:5251
art_effect_passive
Definition: enums.h:99
@ AEP_EXTINGUISH
Definition: enums.h:114
field_type_id fd_smoke
Definition: field_type.cpp:346
field_type_id fd_fatigue
Definition: field_type.cpp:354
static const efftype_id effect_evil("evil")
static const trap_str_id tr_portal("tr_portal")
const morale_type MORALE_FEELING_GOOD("morale_feeling_good")
cata::value_ptr< islot_artifact > artifact
Definition: itype.h:864

References _, Creature::add_effect(), map::add_field(), Character::add_morale(), add_msg(), AEP_ALL_DOWN, AEP_ALL_UP, AEP_DEX_DOWN, AEP_DEX_UP, AEP_EVIL, AEP_EXTINGUISH, AEP_FUN, AEP_HUNGER, AEP_INT_DOWN, AEP_INT_UP, AEP_PBLUE, AEP_PER_DOWN, AEP_PER_UP, AEP_RADIOACTIVE, AEP_SCHIZO, AEP_SMOKE, AEP_SNAKES, AEP_SPEED_DOWN, AEP_SPEED_UP, AEP_STR_DOWN, AEP_STR_UP, AEP_THIRST, item::ammo_capacity(), item::ammo_remaining(), ARTC_FATIGUE, ARTC_HP, ARTC_NULL, ARTC_PAIN, ARTC_PORTAL, ARTC_SOLAR, ARTC_TIME, itype::artifact, item::charges, check_art_charge_req(), Character::dex_cur, effect_evil, fd_fatigue, fd_fire, fd_smoke, Character::get_dex(), Character::get_int(), Character::get_per(), Character::get_rad(), Character::get_str(), Character::hurtall(), Character::int_cur, Character::irradiate(), item::is_armor(), is_in_sunlight(), item::is_tool(), Character::is_worn(), trap::loadid, m, m_bad, m_good, Character::mod_dex_bonus(), Character::mod_fatigue(), map::mod_field_age(), Character::mod_int_bonus(), Creature::mod_pain_noresist(), Character::mod_per_bonus(), Character::mod_rad(), Character::mod_stamina(), Character::mod_stored_kcal(), Character::mod_str_bonus(), Character::mod_thirst(), MORALE_FEELING_GOOD, NUM_ARTCS, calendar::once_every(), one_in(), Character::per_cur, map::points_in_radius(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), map::remove_field(), map::remove_trap(), rng(), Character::str_cur, item::tname(), map::tr_at(), tr_portal, item::type, u, and Character::weapon.

◆ process_voluntary_act_interrupt()

void game::process_voluntary_act_interrupt ( )
private

Definition at line 1703 of file game.cpp.

1704{
1705 if( u.has_effect( effect_sleep ) ) {
1706 // Can't interrupt
1707 return;
1708 }
1709
1710 bool has_activity = u.activity && u.activity.moves_left > 0;
1711 bool is_travelling = u.has_destination() && !u.omt_path.empty();
1712
1713 if( !has_activity && !is_travelling ) {
1714 // Nohing to interrupt
1715 return;
1716 }
1717
1718 // Key poll may be quite expensive, so limit it to 10 times per second.
1719 static auto last_poll = std::chrono::steady_clock::now();
1720 auto now = std::chrono::steady_clock::now();
1721 int64_t difference = std::chrono::duration_cast<std::chrono::milliseconds>
1722 ( now - last_poll ).count();
1723
1724 if( difference > 100 ) {
1726 last_poll = now;
1727 }
1728
1729 // If player is performing a task and a monster is dangerously close, warn them
1730 // regardless of previous safemode warnings
1731 if( has_activity && !u.has_activity( activity_id( "ACT_AIM" ) ) &&
1733 Creature *hostile_critter = is_hostile_very_close();
1734 if( hostile_critter != nullptr ) {
1736 string_format( _( "The %s is dangerously close!" ),
1737 hostile_critter->get_name() ) );
1738 }
1739 }
1740}
bool has_activity(const activity_id &type) const
Check if player currently has a given activity.
Definition: character.cpp:9236
virtual std::string get_name() const =0
void handle_key_blocking_activity()
Definition: game.cpp:2057
int moves_left
The number of moves remaining in this activity before it is complete.

References _, Character::activity, cancel_activity_or_ignore_query(), effect_sleep, Creature::get_name(), handle_key_blocking_activity(), Character::has_activity(), Character::has_destination(), Creature::has_effect(), hostile_spotted_near, player_activity::is_distraction_ignored(), is_hostile_very_close(), player_activity::moves_left, Character::omt_path, string_format(), and u.

Referenced by do_turn().

◆ prompt_dangerous_tile()

bool game::prompt_dangerous_tile ( const tripoint dest_loc) const

Definition at line 9264 of file game.cpp.

9265{
9266 std::vector<std::string> harmful_stuff = get_dangerous_tile( dest_loc );
9267
9268 if( !harmful_stuff.empty() &&
9269 !query_yn( _( "Really step into %s?" ), enumerate_as_string( harmful_stuff ) ) ) {
9270 return false;
9271 }
9272 if( !harmful_stuff.empty() && u.is_mounted() &&
9273 m.tr_at( dest_loc ).loadid == tr_ledge ) {
9274 add_msg( m_warning, _( "Your %s refuses to move over that ledge!" ),
9275 u.mounted_creature->get_name() );
9276 return false;
9277 }
9278 return true;
9279}

References _, add_msg(), enumerate_as_string(), get_dangerous_tile(), Character::is_mounted(), trap::loadid, m, m_warning, Character::mounted_creature, query_yn(), map::tr_at(), tr_ledge, and u.

Referenced by npc_menu(), and walk_move().

◆ quickload()

void game::quickload ( )
private

Definition at line 11854 of file game.cpp.

11855{
11856 const WORLDPTR active_world = world_generator->active_world;
11857 if( active_world == nullptr ) {
11858 return;
11859 }
11860
11861 if( active_world->save_exists( save_t::from_player_name( u.name ) ) ) {
11862 if( moves_since_last_save != 0 ) { // See if we need to reload anything
11863 MAPBUFFER.reset();
11865 try {
11866 setup();
11867 } catch( const std::exception &err ) {
11868 debugmsg( "Error: %s", err.what() );
11869 }
11871 }
11872 } else {
11873 popup_getkey( _( "No saves for %s yet." ), u.name );
11874 }
11875}
bool load(const std::string &world)
Attempt to load first valid save (if any) in world.
Definition: game.cpp:2833
void setup()
Definition: game.cpp:560
static save_t from_player_name(const std::string &name)
int popup_getkey(const char *const mes, Args &&... args)
Definition: output.h:500
bool save_exists(const save_t &name) const

References _, overmapbuffer::clear(), debugmsg, save_t::from_player_name(), load(), MAPBUFFER, moves_since_last_save, Character::name, overmap_buffer, popup_getkey(), mapbuffer::reset(), WORLD::save_exists(), setup(), u, and world_generator.

Referenced by handle_action().

◆ quicksave()

void game::quicksave ( )

Definition at line 11832 of file game.cpp.

11833{
11834 //Don't autosave if the player hasn't done anything since the last autosave/quicksave,
11835 if( !moves_since_last_save ) {
11836 return;
11837 }
11838 add_msg( m_info, _( "Saving game, this may take a while" ) );
11839
11841 popup.message( "%s", _( "Saving game, this may take a while" ) );
11844
11845 time_t now = time( nullptr ); //timestamp for start of saving procedure
11846
11847 //perform save
11848 save();
11849 //Now reset counters for autosaving, so we don't immediately autosave after a quicksave or autosave.
11851 last_save_timestamp = now;
11852}

References _, add_msg(), last_save_timestamp, m_info, moves_since_last_save, popup(), ui_manager::redraw(), refresh_display(), and save().

Referenced by autosave(), and handle_action().

◆ reenter_fullscreen()

void game::reenter_fullscreen ( )

Definition at line 548 of file game.cpp.

549{
550 if( was_fullscreen ) {
551 if( !fullscreen ) {
553 }
554 }
555}

References fullscreen, toggle_fullscreen(), and was_fullscreen.

Referenced by list_items_monsters(), and look_around().

◆ reload()

void game::reload ( item_location loc,
bool  prompt = false,
bool  empty = true 
)

Definition at line 8854 of file game.cpp.

8855{
8857 item *it = loc.get_item();
8858
8859 // bows etc. do not need to reload. select favorite ammo for them instead
8860 if( it->has_flag( "RELOAD_AND_SHOOT" ) ) {
8862 return;
8863 }
8864
8865 switch( u.rate_action_reload( *it ) ) {
8866 case hint_rating::iffy:
8867 if( ( it->is_ammo_container() || it->is_magazine() ) && it->ammo_remaining() > 0 &&
8868 it->ammo_remaining() == it->ammo_capacity() ) {
8869 add_msg( m_info, _( "The %s is already fully loaded!" ), it->tname() );
8870 return;
8871 }
8872 if( it->is_ammo_belt() ) {
8873 const auto &linkage = it->type->magazine->linkage;
8874 if( linkage && !u.has_charges( *linkage, 1 ) ) {
8875 add_msg( m_info, _( "You need at least one %s to reload the %s!" ),
8876 item::nname( *linkage, 1 ), it->tname() );
8877 return;
8878 }
8879 }
8880 if( it->is_watertight_container() && it->is_container_full() ) {
8881 add_msg( m_info, _( "The %s is already full!" ), it->tname() );
8882 return;
8883 }
8884
8885 // intentional fall-through
8886
8887 case hint_rating::cant:
8888 add_msg( m_info, _( "You can't reload a %s!" ), it->tname() );
8889 return;
8890
8891 case hint_rating::good:
8892 break;
8893 }
8894
8895 bool use_loc = true;
8896 if( !it->has_flag( "ALLOWS_REMOTE_USE" ) ) {
8897 it = loc.obtain( u ).get_item();
8898 use_loc = false;
8899 }
8900
8901 // for holsters and ammo pouches try to reload any contained item
8902 if( it->type->can_use( "holster" ) && !it->contents.empty() ) {
8903 it = &it->contents.front();
8904 }
8905
8906 // for bandoliers we currently defer to iuse_actor methods
8907 if( it->is_bandolier() ) {
8908 auto ptr = dynamic_cast<const bandolier_actor *>
8909 ( it->type->get_use( "bandolier" )->get_actor_ptr() );
8910 ptr->reload( u, *it );
8911 return;
8912 }
8913
8915
8916 if( opt.ammo.get_item() == nullptr ) {
8917 return;
8918 }
8919
8920 if( opt ) {
8921 int moves = opt.moves();
8922 if( it->get_var( "dirt", 0 ) > 7800 ) {
8923 add_msg( m_warning, _( "You struggle to reload the fouled %s." ), it->tname() );
8924 moves += 2500;
8925 }
8926
8927 u.assign_activity( activity_id( "ACT_RELOAD" ), moves, opt.qty() );
8928 if( use_loc ) {
8929 u.activity.targets.emplace_back( loc );
8930 } else {
8931 u.activity.targets.emplace_back( u, const_cast<item *>( opt.target ) );
8932 }
8933 u.activity.targets.push_back( std::move( opt.ammo ) );
8934 }
8935}
bool has_charges(const itype_id &it, int quantity, const std::function< bool(const item &)> &filter=return_true< item >) const
Definition: character.cpp:9612
Store ammo and later reload using it.
Definition: iuse_actor.h:885
int moves() const
Definition: item.cpp:7870
const item * target
Definition: item.h:482
int qty() const
Definition: item.h:485
item_location ammo
Definition: item.h:483
item & front()
this is an artifact of the previous code using front() everywhere for contents.
bool empty() const
item * get_item()
Gets the selected item or nullptr.
item_location obtain(Character &ch, int qty=-1)
Move an item from the location to the character inventory.
double get_var(const std::string &name, double default_value) const
Definition: item.cpp:1024
bool is_ammo_container() const
Definition: item.cpp:6506
bool is_watertight_container() const
Whether this is a container which can be used to store liquids.
Definition: item.cpp:6568
static std::string nname(const itype_id &id, unsigned int quantity=1)
Returns the translated item name for the item with given id.
Definition: item.cpp:9743
bool is_ammo_belt() const
Definition: item.cpp:6411
item_contents contents
Definition: item.h:2157
bool is_container_full(bool allow_bucket=false) const
Whether this item has no more free capacity for its current content.
Definition: item.cpp:6686
bool is_bandolier() const
Definition: item.cpp:6416
bool has_flag(const std::string &flag) const
Definition: item.cpp:5186
bool is_magazine() const
Definition: item.cpp:6401
item_location ammo_location
Definition: player.h:650
const void * ptr(const T *p)
\rst Converts p to const void* for pointer formatting.
static item::reload_option favorite_ammo_or_select(const player &u, const item &it, bool empty, bool prompt)
Definition: game.cpp:8835
@ prompt
Definition: pickup.h:30
const use_function * get_use(const std::string &iuse_name) const
Definition: itype.cpp:91
cata::value_ptr< islot_magazine > magazine
Definition: itype.h:859
bool can_use(const std::string &iuse_name) const
Definition: itype.cpp:86

References _, Character::activity, add_msg(), item::reload_option::ammo, item::ammo_capacity(), player::ammo_location, item::ammo_remaining(), Character::assign_activity(), itype::can_use(), cant, item::contents, item_contents::empty(), favorite_ammo_or_select(), item_contents::front(), use_function::get_actor_ptr(), item_location::get_item(), itype::get_use(), item::get_var(), good, Character::has_charges(), item::has_flag(), iffy, item::is_ammo_belt(), item::is_ammo_container(), item::is_bandolier(), item::is_container_full(), item::is_magazine(), item::is_watertight_container(), m_info, m_warning, itype::magazine, item_location::make_dirty(), avatar_action::move(), item::reload_option::moves(), item::nname(), item_location::obtain(), pickup::prompt, ranged::prompt_select_default_ammo_for(), ptr(), item::reload_option::qty(), player::rate_action_reload(), item::reload_option::target, player_activity::targets, item::tname(), item::type, and u.

Referenced by inventory_item_menu(), reload_item(), and reload_wielded().

◆ reload_item()

void game::reload_item ( )

Definition at line 8938 of file game.cpp.

8939{
8940 item_location item_loc = inv_map_splice( [&]( const item & it ) {
8941 return u.rate_action_reload( it ) == hint_rating::good;
8942 }, _( "Reload item" ), 1, _( "You have nothing to reload." ) );
8943
8944 if( !item_loc ) {
8945 add_msg( _( "Never mind." ) );
8946 return;
8947 }
8948
8949 reload( item_loc );
8950}
item_location inv_map_splice(item_filter filter, const std::string &title, int radius=0, const std::string &none_message="")
Custom-filtered menu for inventory and nearby items and those that within specified radius.

References _, add_msg(), good, inv_map_splice(), player::rate_action_reload(), reload(), and u.

Referenced by handle_action().

◆ reload_npcs()

void game::reload_npcs ( )

Unloads, then loads the NPCs.

Definition at line 960 of file game.cpp.

961{
962 // TODO: Make it not invoke the "on_unload" command for the NPCs that will be loaded anyway
963 // and not invoke "on_load" for those NPCs that avoided unloading this way.
964 unload_npcs();
965 load_npcs();
966}

References load_npcs(), and unload_npcs().

Referenced by load(), overmap_npc_move(), vertical_move(), and vertical_shift().

◆ reload_tileset()

void game::reload_tileset ( )

Definition at line 521 of file game.cpp.

522{
523#if defined(TILES)
524 try {
525 tilecontext->reinit();
526 tilecontext->load_tileset( get_option<std::string>( "TILES" ), false, true );
527 tilecontext->do_tile_loading_report();
528 } catch( const std::exception &err ) {
529 popup( _( "Loading the tileset failed: %s" ), err.what() );
530 }
531 g->reset_zoom();
532 g->mark_main_ui_adaptor_resize();
533#endif // TILES
534}

References _, g, and popup().

Referenced by handle_action().

◆ reload_weapon()

void game::reload_weapon ( bool  try_everything = true)

Definition at line 8962 of file game.cpp.

8963{
8964 // As a special streamlined activity, hitting reload repeatedly should:
8965 // Reload wielded gun
8966 // First reload a magazine if necessary.
8967 // Then load said magazine into gun.
8968 // Reload magazines that are compatible with the current gun.
8969 // Reload other guns in inventory.
8970 // Reload misc magazines in inventory.
8971 std::vector<item_location> reloadables = u.find_reloadables();
8972 std::sort( reloadables.begin(), reloadables.end(),
8973 [this]( const item_location & a, const item_location & b ) {
8974 const item *ap = a.get_item();
8975 const item *bp = b.get_item();
8976 // Current wielded weapon comes first.
8977 if( this->u.is_wielding( *bp ) ) {
8978 return false;
8979 }
8980 if( this->u.is_wielding( *ap ) ) {
8981 return true;
8982 }
8983 // Second sort by affiliation with wielded gun
8984 const std::set<itype_id> compatible_magazines = this->u.weapon.magazine_compatible();
8985 const bool mag_ap = compatible_magazines.count( ap->typeId() ) > 0;
8986 const bool mag_bp = compatible_magazines.count( bp->typeId() ) > 0;
8987 if( mag_ap != mag_bp ) {
8988 return mag_ap;
8989 }
8990 // Third sort by gun vs magazine,
8991 if( ap->is_gun() != bp->is_gun() ) {
8992 return ap->is_gun();
8993 }
8994 // Finally sort by speed to reload.
8995 return ( ap->get_reload_time() * ( ap->ammo_capacity() - ap->ammo_remaining() ) ) <
8996 ( bp->get_reload_time() * ( bp->ammo_capacity() - bp->ammo_remaining() ) );
8997 } );
8998 for( item_location &candidate : reloadables ) {
8999 std::vector<item::reload_option> ammo_list;
9000 u.list_ammo( *candidate.get_item(), ammo_list, false );
9001 if( !ammo_list.empty() ) {
9002 reload( candidate, false, false );
9003 return;
9004 }
9005 }
9006 // Just for testing, bail out here to avoid unwanted side effects.
9007 if( !try_everything ) {
9008 return;
9009 }
9010 // If we make it here and haven't found anything to reload, start looking elsewhere.
9011 vehicle *veh = veh_pointer_or_null( m.veh_at( u.pos() ) );
9012 turret_data turret;
9013 if( veh && ( turret = veh->turret_query( u.pos() ) ) && turret.can_reload() ) {
9014 item::reload_option opt = g->u.select_ammo( *turret.base(), true );
9015 if( opt ) {
9016 g->u.assign_activity( activity_id( "ACT_RELOAD" ), opt.moves(), opt.qty() );
9017 g->u.activity.targets.emplace_back( turret.base() );
9018 g->u.activity.targets.push_back( std::move( opt.ammo ) );
9019 }
9020 return;
9021 }
9022
9023 reload_item();
9024}
std::vector< item_location > find_reloadables()
Searches for weapons and magazines that can be reloaded.
Definition: character.cpp:2697
bool list_ammo(const item &base, std::vector< item::reload_option > &ammo_list, bool include_empty_mags=true, bool include_potential=false) const
Definition: player.cpp:2284
bool can_reload() const
Definition: turret.cpp:212
item_location base()
Get base item location.
Definition: turret.cpp:84
turret_data turret_query(vehicle_part &pt)
Get firing data for a turret.
Definition: turret.cpp:55
constexpr double a
Definition: magic.cpp:1030
constexpr double b
Definition: magic.cpp:1031

References a, b, Character::find_reloadables(), and u.

Referenced by handle_action().

◆ reload_wielded()

void game::reload_wielded ( bool  prompt = false)

Definition at line 8952 of file game.cpp.

8953{
8954 if( u.weapon.is_null() || !u.weapon.is_reloadable() ) {
8955 add_msg( _( "You aren't holding something you can reload." ) );
8956 return;
8957 }
8958 item_location item_loc = item_location( u, &u.weapon );
8959 reload( item_loc, prompt );
8960}
bool is_null() const
Definition: item.cpp:731
bool is_reloadable() const
Is it ever possible to reload this item? Only the base item is considered with any mods ignored.
Definition: item.cpp:9651

References _, add_msg(), item::is_null(), item::is_reloadable(), pickup::prompt, reload(), u, and Character::weapon.

Referenced by handle_action().

◆ remoteveh()

vehicle * game::remoteveh ( )

Returns the current remotely controlled vehicle.

Definition at line 2574 of file game.cpp.

2575{
2577 return remoteveh_cache;
2578 }
2580 std::stringstream remote_veh_string( u.get_value( "remote_controlling_vehicle" ) );
2581 if( remote_veh_string.str().empty() ||
2583 remoteveh_cache = nullptr;
2584 } else {
2585 tripoint vp;
2586 remote_veh_string >> vp.x >> vp.y >> vp.z;
2587 vehicle *veh = veh_pointer_or_null( m.veh_at( vp ) );
2588 if( veh && veh->fuel_left( itype_battery, true ) > 0 ) {
2589 remoteveh_cache = veh;
2590 } else {
2591 remoteveh_cache = nullptr;
2592 }
2593 }
2594 return remoteveh_cache;
2595}
vehicle * remoteveh_cache
Definition: game.h:1093
int fuel_left(const itype_id &ftype, bool recurse=false) const
Definition: vehicle.cpp:3359
static const bionic_id bio_remote("bio_remote")
static const itype_id itype_remotevehcontrol("remotevehcontrol")
static const itype_id itype_battery("battery")

References bio_remote, vehicle::fuel_left(), Creature::get_value(), Character::has_active_bionic(), Character::has_active_item(), itype_battery, itype_remotevehcontrol, m, remoteveh_cache, remoteveh_cache_time, calendar::turn, u, map::veh_at(), veh_pointer_or_null(), tripoint::x, tripoint::y, and tripoint::z.

Referenced by control_vehicle(), and handle_action().

◆ remove_npc_follower()

void game::remove_npc_follower ( const character_id id)

Remove follower id from follower set.

Definition at line 1966 of file game.cpp.

1967{
1968 follower_ids.erase( id );
1969 u.follower_ids.erase( id );
1970}

References follower_ids, player::follower_ids, and u.

Referenced by cleanup_dead().

◆ remove_zombie()

void game::remove_zombie ( const monster critter)

Definition at line 5046 of file game.cpp.

5047{
5048 critter_tracker->remove( critter );
5049}

References critter_tracker.

Referenced by despawn_monster(), disable_robot(), start_game(), and vertical_move().

◆ replace_stair_monsters()

void game::replace_stair_monsters ( )
private

Definition at line 11352 of file game.cpp.

11353{
11354 for( auto &elem : coming_to_stairs ) {
11355 elem.staircount = 0;
11356 const tripoint pnt( elem.pos().xy(), get_levz() );
11357 place_critter_around( make_shared_fast<monster>( elem ), pnt, 10 );
11358 }
11359
11360 coming_to_stairs.clear();
11361}
std::vector< monster > coming_to_stairs
Definition: game.h:1031

References coming_to_stairs, get_levz(), and place_critter_around().

◆ reset_item_list_state()

void game::reset_item_list_state ( const catacurses::window window,
int  height,
bool  bRadiusSort 
)
private

Definition at line 7436 of file game.cpp.

7437{
7438 const int width = getmaxx( window );
7439 for( int i = 1; i < TERMX; i++ ) {
7440 if( i < width ) {
7441 mvwputch( window, point( i, 0 ), c_light_gray, LINE_OXOX ); // -
7442 mvwputch( window, point( i, TERMY - height - 1 ), c_light_gray,
7443 LINE_OXOX ); // -
7444 }
7445
7446 if( i < TERMY - height ) {
7447 mvwputch( window, point( 0, i ), c_light_gray, LINE_XOXO ); // |
7448 mvwputch( window, point( width - 1, i ), c_light_gray, LINE_XOXO ); // |
7449 }
7450 }
7451
7452 mvwputch( window, point_zero, c_light_gray, LINE_OXXO ); // |^
7453 mvwputch( window, point( width - 1, 0 ), c_light_gray, LINE_OOXX ); // ^|
7454
7455 mvwputch( window, point( 0, TERMY - height - 1 ), c_light_gray,
7456 LINE_XXXO ); // |-
7457 mvwputch( window, point( width - 1, TERMY - height - 1 ), c_light_gray,
7458 LINE_XOXX ); // -|
7459
7460 mvwprintz( window, point( 2, 0 ), c_light_green, "<Tab> " );
7461 wprintz( window, c_white, _( "Items" ) );
7462
7463 std::string sSort;
7464 if( bRadiusSort ) {
7465 //~ Sort type: distance.
7466 sSort = _( "<s>ort: dist" );
7467 } else {
7468 //~ Sort type: category.
7469 sSort = _( "<s>ort: cat" );
7470 }
7471
7472 int letters = utf8_width( sSort );
7473
7474 shortcut_print( window, point( getmaxx( window ) - letters, 0 ), c_white, c_light_green, sSort );
7475
7476 std::vector<std::string> tokens;
7477 if( !sFilter.empty() ) {
7478 tokens.emplace_back( _( "<R>eset" ) );
7479 }
7480
7481 tokens.emplace_back( _( "<E>xamine" ) );
7482 tokens.emplace_back( _( "<C>ompare" ) );
7483 tokens.emplace_back( _( "<F>ilter" ) );
7484 tokens.emplace_back( _( "<+/->Priority" ) );
7485
7486 int gaps = tokens.size() + 1;
7487 letters = 0;
7488 int n = tokens.size();
7489 for( int i = 0; i < n; i++ ) {
7490 letters += utf8_width( tokens[i] ) - 2; //length ignores < >
7491 }
7492
7493 int usedwidth = letters;
7494 const int gap_spaces = ( width - usedwidth ) / gaps;
7495 usedwidth += gap_spaces * gaps;
7496 point pos( gap_spaces + ( width - usedwidth ) / 2, TERMY - height - 1 );
7497
7498 for( int i = 0; i < n; i++ ) {
7499 pos.x += shortcut_print( window, pos, c_white, c_light_green,
7500 tokens[i] ) + gap_spaces;
7501 }
7502}
#define LINE_OOXX
Definition: output.h:43
#define LINE_OXXO
Definition: output.h:42

References _, c_light_gray, c_light_green, c_white, catacurses::getmaxx(), LINE_OOXX, LINE_OXOX, LINE_OXXO, LINE_XOXO, LINE_XOXX, LINE_XXXO, mvwprintz(), mvwputch(), point_zero, sFilter, shortcut_print(), TERMX, TERMY, utf8_width(), wprintz(), and point::x.

Referenced by list_items().

◆ reset_light_level()

void game::reset_light_level ( )

Definition at line 3935 of file game.cpp.

3936{
3937 for( float &lev : latest_lightlevels ) {
3938 lev = -std::numeric_limits<float>::max();
3939 }
3940}

References latest_lightlevels.

Referenced by do_turn(), and game().

◆ reset_npc_dispositions()

void game::reset_npc_dispositions ( )
private

Definition at line 3010 of file game.cpp.

3011{
3012 for( auto elem : follower_ids ) {
3013 shared_ptr_fast<npc> npc_to_get = overmap_buffer.find_npc( elem );
3014 if( !npc_to_get ) {
3015 continue;
3016 }
3017 npc *npc_to_add = npc_to_get.get();
3018 npc_to_add->chatbin.missions.clear();
3019 npc_to_add->chatbin.missions_assigned.clear();
3020 npc_to_add->mission = NPC_MISSION_NULL;
3021 npc_to_add->chatbin.mission_selected = nullptr;
3022 npc_to_add->set_attitude( NPCATT_NULL );
3023 npc_to_add->op_of_u.anger = 0;
3024 npc_to_add->op_of_u.fear = 0;
3025 npc_to_add->op_of_u.trust = 0;
3026 npc_to_add->op_of_u.value = 0;
3027 npc_to_add->op_of_u.owed = 0;
3028 npc_to_add->set_fac( faction_id( "no_faction" ) );
3030 npc_to_add->global_omt_location(),
3031 npc_to_add->getID() ) );
3032
3033 }
3034
3035}
void set_attitude(npc_attitude new_attitude)
Definition: npc.cpp:3141
npc_chatbin chatbin
Definition: npc.h:1329
void add_new_mission(mission *miss)
See npc_chatbin::add_new_mission.
Definition: npc.cpp:2637
npc_opinion op_of_u
Definition: npc.h:1328
void set_fac(const faction_id &id)
Definition: npc.cpp:466
std::vector< mission * > missions_assigned
Mission that have been assigned by this NPC to a player character.
Definition: npc.h:752
mission * mission_selected
The mission (if any) that we talk about right now.
Definition: npc.h:757
std::vector< mission * > missions
Missions that the NPC can give out.
Definition: npc.h:748
int value
Definition: npc.h:242
int trust
Definition: npc.h:240
int owed
Definition: npc.h:244
int fear
Definition: npc.h:241
int anger
Definition: npc.h:243

References npc::add_new_mission(), npc_opinion::anger, npc::chatbin, npc_opinion::fear, overmapbuffer::find_npc(), follower_ids, Character::getID(), Character::global_omt_location(), npc::mission, npc_chatbin::mission_selected, npc_chatbin::missions, npc_chatbin::missions_assigned, NPC_MISSION_NULL, NPCATT_NULL, npc::op_of_u, ORIGIN_ANY_NPC, overmap_buffer, npc_opinion::owed, mission::reserve_random(), npc::set_attitude(), npc::set_fac(), npc_opinion::trust, and npc_opinion::value.

Referenced by cleanup_at_end().

◆ reset_zoom()

void game::reset_zoom ( )

Definition at line 7351 of file game.cpp.

7352{
7353#if defined(TILES)
7355 rescale_tileset( tileset_zoom );
7356#endif // TILES
7357}

References DEFAULT_TILESET_ZOOM, and tileset_zoom.

◆ revive_corpse()

bool game::revive_corpse ( const tripoint p,
item it 
)

Revives a corpse at given location.

The monster type and some of its properties are deducted from the corpse. If reviving succeeds, the location is guaranteed to have a new monster there (see critter_at).

Parameters
pThe place where to put the revived monster.
itThe corpse item, it must be a valid corpse (see item::is_corpse).
Returns
Whether the corpse has actually been redivided. Reviving may fail for many reasons, including no space to put the monster, corpse being to much damaged etc. If the monster was revived, the caller should remove the corpse item. If reviving failed, the item is unchanged, as is the environment (no new monsters).

Definition at line 5177 of file game.cpp.

5178{
5179 if( !it.is_corpse() ) {
5180 debugmsg( "Tried to revive a non-corpse." );
5181 return false;
5182 }
5183 shared_ptr_fast<monster> newmon_ptr = make_shared_fast<monster>
5184 ( it.get_mtype()->id );
5185 monster &critter = *newmon_ptr;
5186 critter.init_from_item( it );
5187 if( critter.get_hp() < 1 ) {
5188 // Failed reanimation due to corpse being too burned
5189 return false;
5190 }
5191 if( it.has_flag( "FIELD_DRESS" ) || it.has_flag( "FIELD_DRESS_FAILED" ) ||
5192 it.has_flag( "QUARTERED" ) ) {
5193 // Failed reanimation due to corpse being butchered
5194 return false;
5195 }
5196
5197 critter.no_extra_death_drops = true;
5198 critter.add_effect( effect_downed, 5_turns, num_bp );
5199 for( const item &component : it.components ) {
5200 critter.corpse_components.push_back( component );
5201 }
5202
5203 if( it.get_var( "zlave" ) == "zlave" ) {
5204 critter.add_effect( effect_pacified, 1_turns, num_bp );
5205 critter.add_effect( effect_pet, 1_turns, num_bp );
5206 }
5207
5208 if( it.get_var( "no_ammo" ) == "no_ammo" ) {
5209 for( auto &ammo : critter.ammo ) {
5210 ammo.second = 0;
5211 }
5212 }
5213
5214 return place_critter_at( newmon_ptr, p );
5215}
monster * place_critter_at(const mtype_id &id, const tripoint &p)
Adds critters to the reality bubble, creating them if necessary.
Definition: game.cpp:4974
const mtype * get_mtype() const
Definition: item.cpp:6469
std::list< item > components
Definition: item.h:2158
bool is_corpse() const
Whether this is a corpse item.
Definition: item.cpp:6464
int get_hp(const bodypart_id &) const override
Definition: monster.cpp:2898
bool no_extra_death_drops
Definition: monster.h:482
std::vector< item > corpse_components
Definition: monster.h:459
void init_from_item(const item &itm)
Initialize values like speed / hp from data of an item.
Definition: monster.cpp:2762
static const efftype_id effect_downed("downed")
static const efftype_id effect_pacified("pacified")

References monster::add_effect(), monster::ammo, item::components, monster::corpse_components, debugmsg, effect_downed, effect_pacified, effect_pet, monster::get_hp(), item::get_mtype(), item::get_var(), item::has_flag(), mtype::id, monster::init_from_item(), item::is_corpse(), monster::no_extra_death_drops, num_bp, and place_critter_at().

◆ save()

bool game::save ( )

Returns false if saving failed.

Definition at line 3111 of file game.cpp.

3112{
3113 try {
3114 if( !save_player_data() ||
3116 !save_artifacts() ||
3117 !save_maps() ||
3118 !get_auto_pickup().save_character() ||
3120 !get_safemode().save_character() ||
3121 !write_to_file( get_world_base_save_path() + "/uistate.json", [&]( std::ostream & fout ) {
3122 JsonOut jsout( fout );
3123 uistate.serialize( jsout );
3124 }, _( "uistate data" ) ) ) {
3125 return false;
3126 } else {
3127 world_generator->active_world->add_save( save_t::from_player_name( u.name ) );
3128 return true;
3129 }
3130 } catch( std::ios::failure &err ) {
3131 popup( _( "Failed to save game data" ) );
3132 return false;
3133 }
3134}
void write_to_file(const std::string &path, const std::function< void(std::ostream &)> &writer)
Definition: json.h:580
bool save_player_data()
Definition: game.cpp:3065
void serialize(JsonOut &json) const
@ failure
Definition: behavior.h:20

References _, behavior::failure, save_t::from_player_name(), get_auto_notes_settings(), get_auto_pickup(), get_safemode(), get_world_base_save_path(), Character::name, popup(), save(), save_artifacts(), save_factions_missions_npcs(), save_maps(), save_player_data(), uistatedata::serialize(), u, uistate, world_generator, and write_to_file().

Referenced by handle_action(), quicksave(), and save().

◆ save_artifacts()

bool game::save_artifacts ( )
private

Definition at line 3046 of file game.cpp.

3047{
3048 std::string artfilename = get_world_base_save_path() + "/" + SAVE_ARTIFACTS;
3049 return ::save_artifacts( artfilename );
3050}
bool save_artifacts(const std::string &path)
Definition: artifact.cpp:1277

References get_world_base_save_path(), SAVE_ARTIFACTS(), and save_artifacts().

Referenced by cleanup_at_end(), and save().

◆ save_cyborg()

void game::save_cyborg ( item cyborg,
const tripoint couch_pos,
player installer 
)

Turns Broken Cyborg monster into Cyborg NPC via surgery.

Definition at line 5217 of file game.cpp.

5218{
5219 int assist_bonus = installer.get_effect_int( effect_assisted );
5220
5221 float adjusted_skill = installer.bionics_adjusted_skill( skill_firstaid,
5224 -1 );
5225
5226 int damage = cyborg->damage();
5227 int dmg_lvl = cyborg->damage_level( 4 );
5228 int difficulty = 12;
5229
5230 if( damage != 0 ) {
5231
5232 popup( _( "WARNING: Patient's body is damaged. Difficulty of the procedure is increased by %s." ),
5233 dmg_lvl );
5234
5235 // Damage of the cyborg increases difficulty
5236 difficulty += dmg_lvl;
5237 }
5238
5239 int chance_of_success = bionic_manip_cos( adjusted_skill + assist_bonus, difficulty );
5240 int success = chance_of_success - rng( 1, 100 );
5241
5242 if( !g->u.query_yn(
5243 _( "WARNING: %i percent chance of SEVERE damage to all body parts! Continue anyway?" ),
5244 100 - static_cast<int>( chance_of_success ) ) ) {
5245 return;
5246 }
5247
5248 if( success > 0 ) {
5249 add_msg( m_good, _( "Successfully removed Personality override." ) );
5250 add_msg( m_bad, _( "Autodoc immediately destroys the CBM upon removal." ) );
5251
5252 m.i_rem( couch_pos, cyborg );
5253
5254 const string_id<npc_template> npc_cyborg( "cyborg_rescued" );
5255 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
5256 tmp->normalize();
5257 tmp->load_npc_template( npc_cyborg );
5258 tmp->spawn_at_precise( { get_levx(), get_levy() }, couch_pos );
5260 tmp->hurtall( dmg_lvl * 10, nullptr );
5261 tmp->add_effect( effect_downed, rng( 1_turns, 4_turns ), num_bp, 0, true );
5262 load_npcs();
5263
5264 } else {
5265 const int failure_level = static_cast<int>( std::sqrt( std::abs( success ) * 4.0 * difficulty /
5266 adjusted_skill ) );
5267 const int fail_type = std::min( 5, failure_level );
5268 switch( fail_type ) {
5269 case 1:
5270 case 2:
5271 add_msg( m_info, _( "The removal fails." ) );
5272 add_msg( m_bad, _( "The body is damaged." ) );
5273 cyborg->set_damage( damage + 1000 );
5274 break;
5275 case 3:
5276 case 4:
5277 add_msg( m_info, _( "The removal fails badly." ) );
5278 add_msg( m_bad, _( "The body is badly damaged!" ) );
5279 cyborg->set_damage( damage + 2000 );
5280 break;
5281 case 5:
5282 add_msg( m_info, _( "The removal is a catastrophe." ) );
5283 add_msg( m_bad, _( "The body is destroyed!" ) );
5284 m.i_rem( couch_pos, cyborg );
5285 break;
5286 default:
5287 break;
5288 }
5289
5290 }
5291
5292}
int bionic_manip_cos(float adjusted_skill, int bionic_difficulty)
Definition: bionics.cpp:1889
float bionics_adjusted_skill(const skill_id &most_important_skill, const skill_id &important_skill, const skill_id &least_important_skill, int skill_level=-1)
Calculate skill for (un)installing bionics.
Definition: bionics.cpp:1846
item & set_damage(int qty)
Filter setting damage constrained by min_damage and max_damage.
Definition: item.cpp:713
int damage_level(int max) const
Scale item damage to the given number of levels.
Definition: item.cpp:700
int damage() const
How much damage has the item sustained?
Definition: item.cpp:695
map_stack::iterator i_rem(const tripoint &p, map_stack::const_iterator it)
Definition: map.cpp:4082
static const skill_id skill_computer("computer")
static const efftype_id effect_assisted("assisted")
static const skill_id skill_electronics("electronics")
@ success
Definition: behavior.h:20

References _, add_msg(), bionic_manip_cos(), Character::bionics_adjusted_skill(), item::damage(), item::damage_level(), effect_assisted, effect_downed, g, Creature::get_effect_int(), get_levx(), get_levy(), map::i_rem(), overmapbuffer::insert_npc(), load_npcs(), m, m_bad, m_good, m_info, num_bp, overmap_buffer, popup(), rng(), item::set_damage(), skill_computer, skill_electronics, skill_firstaid, and behavior::success.

◆ save_factions_missions_npcs()

bool game::save_factions_missions_npcs ( )
private

Definition at line 3038 of file game.cpp.

3039{
3040 std::string masterfile = get_world_base_save_path() + "/" + SAVE_MASTER;
3041 return write_to_file( masterfile, [&]( std::ostream & fout ) {
3042 serialize_master( fout );
3043 }, _( "factions data" ) );
3044}
void serialize_master(std::ostream &fout)
Definition: savegame.cpp:1238

References _, get_world_base_save_path(), SAVE_MASTER(), serialize_master(), and write_to_file().

Referenced by cleanup_at_end(), and save().

◆ save_maps()

bool game::save_maps ( )
private

Definition at line 3052 of file game.cpp.

3053{
3054 try {
3055 m.save();
3056 overmap_buffer.save(); // can throw
3057 MAPBUFFER.save(); // can throw
3058 return true;
3059 } catch( const std::exception &err ) {
3060 popup( _( "Failed to save the maps: %s" ), err.what() );
3061 return false;
3062 }
3063}
void save(bool delete_after_save=false)
Store all submaps in this instance into savefiles.
Definition: mapbuffer.cpp:103

References _, m, MAPBUFFER, overmap_buffer, popup(), map::save(), overmapbuffer::save(), and mapbuffer::save().

Referenced by cleanup_at_end(), and save().

◆ save_player_data()

bool game::save_player_data ( )
private

Definition at line 3065 of file game.cpp.

3066{
3067 const std::string playerfile = get_player_base_save_path();
3068
3069 const bool saved_data = write_to_file( playerfile + SAVE_EXTENSION, [&]( std::ostream & fout ) {
3070 serialize( fout );
3071 }, _( "player data" ) );
3072 const bool saved_map_memory = u.save_map_memory();
3073 const bool saved_log = write_to_file( playerfile + SAVE_EXTENSION_LOG, [&](
3074 std::ostream & fout ) {
3075 fout << memorial().dump();
3076 }, _( "player memorial" ) );
3077#if defined(__ANDROID__)
3078 const bool saved_shortcuts = write_to_file( playerfile + SAVE_EXTENSION_SHORTCUTS, [&](
3079 std::ostream & fout ) {
3080 save_shortcuts( fout );
3081 }, _( "quick shortcuts" ) );
3082#endif
3083
3084 return saved_data && saved_map_memory && saved_log
3085#if defined(__ANDROID__)
3086 && saved_shortcuts
3087#endif
3088 ;
3089}
bool save_map_memory()
Definition: avatar.cpp:129
std::string get_player_base_save_path() const
Base path for saving player data.
Definition: game.cpp:12569
void serialize(std::ostream &fout)
Saving and loading functions.
Definition: savegame.cpp:69
std::string dump() const
Concatenates all of the memorial log entries, delimiting them with newlines, and returns the resultin...

References _, memorial_logger::dump(), get_player_base_save_path(), memorial(), SAVE_EXTENSION(), SAVE_EXTENSION_LOG(), SAVE_EXTENSION_SHORTCUTS(), avatar::save_map_memory(), serialize(), u, and write_to_file().

Referenced by save().

◆ serialize()

void game::serialize ( std::ostream &  fout)

Saving and loading functions.

Definition at line 69 of file savegame.cpp.

70{
71 /*
72 * Format version 12: Fully json, save the header. Weather and memorial exist elsewhere.
73 * To prevent (or encourage) confusion, there is no version 8. (cata 0.8 uses v7)
74 */
75 // Header
76 fout << "# version " << savegame_version << std::endl;
77
78 JsonOut json( fout, true ); // pretty-print
79
80 json.start_object();
81 // basic game state information.
82 json.member( "turn", calendar::turn );
84 json.member( "calendar_start", calendar_config._start_of_cataclysm );
85 json.member( "game_start", calendar_config._start_of_game );
86 json.member( "initial_season", static_cast<int>( calendar_config._initial_season ) );
87 json.member( "auto_travel_mode", auto_travel_mode );
88 json.member( "run_mode", static_cast<int>( safe_mode ) );
89 json.member( "mostseen", mostseen );
90 // current map coordinates
91 tripoint pos_sm = m.get_abs_sub();
92 const point pos_om = sm_to_om_remain( pos_sm.x, pos_sm.y );
93 json.member( "levx", pos_sm.x );
94 json.member( "levy", pos_sm.y );
95 json.member( "levz", pos_sm.z );
96 json.member( "om_x", pos_om.x );
97 json.member( "om_y", pos_om.y );
98
99 json.member( "grscent", scent.serialize() );
100 json.member( "typescent", scent.serialize( true ) );
101
102 // Then each monster
103 json.member( "active_monsters", *critter_tracker );
104 json.member( "stair_monsters", coming_to_stairs );
105
106 // save stats.
107 json.member( "kill_tracker", *kill_tracker_ptr );
108 json.member( "stats_tracker", *stats_tracker_ptr );
109 json.member( "achievements_tracker", *achievements_tracker_ptr );
110
111 json.member( "token_provider", *token_provider_ptr );
112
113 json.member( "player", u );
114 Messages::serialize( json );
115
116 json.end_object();
117}
A class that keeps time data other than current time.
Definition: calendar.h:530
season_type _initial_season
Definition: calendar.h:534
time_point _start_of_game
Definition: calendar.h:533
time_point _start_of_cataclysm
Definition: calendar.h:532
pimpl< drop_token_provider > token_provider_ptr
Definition: game.h:1023
std::string serialize(bool is_type=false) const
Definition: savegame.cpp:119
point sm_to_om_remain(int &x, int &y)
void serialize(JsonOut &json)
Definition: messages.cpp:321
calendar_config config
const int savegame_version
Definition: savegame.cpp:57

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, achievements_tracker_ptr, auto_travel_mode, coming_to_stairs, calendar::config, critter_tracker, JsonOut::end_object(), map::get_abs_sub(), kill_tracker_ptr, m, JsonOut::member(), mostseen, safe_mode, savegame_version, scent, scent_map::serialize(), Messages::serialize(), sm_to_om_remain(), JsonOut::start_object(), stats_tracker_ptr, token_provider_ptr, calendar::turn, u, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by save_player_data().

◆ serialize_master()

void game::serialize_master ( std::ostream &  fout)
private

Definition at line 1238 of file savegame.cpp.

1239{
1240 fout << "# version " << savegame_version << std::endl;
1241 try {
1242 JsonOut json( fout, true ); // pretty-print
1243 json.start_object();
1244
1245 json.member( "next_mission_id", next_mission_id );
1246 json.member( "next_npc_id", next_npc_id );
1247
1248 json.member( "active_missions" );
1249 mission::serialize_all( json );
1250
1251 json.member( "factions", *faction_manager_ptr );
1252 json.member( "seed", seed );
1253
1254 json.member( "weather" );
1255 json.start_object();
1256 json.member( "lightning", get_weather().lightning_active );
1257 json.end_object();
1258
1259 json.end_object();
1260 } catch( const JsonError &e ) {
1261 debugmsg( "error saving to %s: %s", SAVE_MASTER, e.c_str() );
1262 }
1263}
Definition: json.h:51
const char * c_str() const noexcept
Definition: json.h:54
static void serialize_all(JsonOut &json)
Definition: savegame.cpp:1229

References JsonError::c_str(), debugmsg, JsonOut::end_object(), faction_manager_ptr, get_weather, JsonOut::member(), next_mission_id, next_npc_id, SAVE_MASTER(), savegame_version, seed, mission::serialize_all(), and JsonOut::start_object().

Referenced by save_factions_missions_npcs().

◆ set_critter_died()

void game::set_critter_died ( )

If invoked, dead will be cleaned this turn.

Definition at line 1874 of file game.cpp.

1875{
1876 critter_died = true;
1877}

References critter_died.

◆ set_driving_view_offset()

void game::set_driving_view_offset ( const point p)

Definition at line 1691 of file game.cpp.

1692{
1693 // remove the previous driving offset,
1694 // store the new offset and apply the new offset.
1701}

References driving_view_offset, u, player::view_offset, point::x, tripoint::x, point::y, and tripoint::y.

Referenced by calc_driving_offset(), and cleanup_at_end().

◆ set_npcs_dirty()

void game::set_npcs_dirty ( )

If invoked, NPCs will be reloaded before next turn.

Definition at line 1869 of file game.cpp.

1870{
1871 npcs_dirty = true;
1872}

References npcs_dirty.

◆ set_safe_mode()

void game::set_safe_mode ( safe_mode_type  mode)

Definition at line 9192 of file game.cpp.

9193{
9194 safe_mode = mode;
9196}

References safe_mode, and safe_mode_warning_logged.

Referenced by handle_action(), and mon_info_update().

◆ set_zoom()

void game::set_zoom ( int  level)

Definition at line 7359 of file game.cpp.

7360{
7361#if defined(TILES)
7362 if( tileset_zoom != level ) {
7363 tileset_zoom = level;
7364 rescale_tileset( tileset_zoom );
7365 }
7366#else
7367 static_cast<void>( level );
7368#endif // TILES
7369}

References tileset_zoom.

Referenced by look_around().

◆ setremoteveh()

void game::setremoteveh ( vehicle veh)

Sets the current remotely controlled vehicle.

Definition at line 2597 of file game.cpp.

2598{
2600 remoteveh_cache = veh;
2601 if( veh != nullptr && !u.has_active_bionic( bio_remote ) &&
2603 debugmsg( "Tried to set remote vehicle without bio_remote or remotevehcontrol" );
2604 veh = nullptr;
2605 }
2606
2607 if( veh == nullptr ) {
2608 u.remove_value( "remote_controlling_vehicle" );
2609 return;
2610 }
2611
2612 std::stringstream remote_veh_string;
2613 const tripoint vehpos = veh->global_pos3();
2614 remote_veh_string << vehpos.x << ' ' << vehpos.y << ' ' << vehpos.z;
2615 u.set_value( "remote_controlling_vehicle", remote_veh_string.str() );
2616}
void remove_value(const std::string &key)
Definition: creature.cpp:1336

References bio_remote, debugmsg, vehicle::global_pos3(), Character::has_active_bionic(), Character::has_active_item(), itype_remotevehcontrol, remoteveh_cache, remoteveh_cache_time, Creature::remove_value(), Creature::set_value(), calendar::turn, u, tripoint::x, tripoint::y, and tripoint::z.

◆ setup()

void game::setup ( )

Definition at line 560 of file game.cpp.

561{
562 loading_ui ui( true );
563 {
566 popup.message( "%s", _( "Please wait while the world data loads…\nLoading core data" ) );
569
571 }
572
574
575 if( get_option<bool>( "ELEVATED_BRIDGES" ) && !get_option<bool>( "ZLEVELS" ) ) {
576 debugmsg( "\"Elevated bridges\" mod requires z-levels to be ENABLED to work properly!" );
577 }
578
579 m = map( get_option<bool>( "ZLEVELS" ) );
580
582 next_mission_id = 1;
583 new_game = true;
584 uquit = QUIT_NO; // We haven't quit the game
585 bVMonsterLookFire = true;
586
587 // invalidate calendar caches in case we were previously playing
588 // a different world
589 calendar::set_eternal_season( ::get_option<bool>( "ETERNAL_SEASON" ) );
590 calendar::set_season_length( ::get_option<int>( "SEASON_LENGTH" ) );
591
594
595 turnssincelastmon = 0; //Auto safe mode init
596
599 coming_to_stairs.clear();
600 active_npc.clear();
601 faction_manager_ptr->clear();
606
607 SCT.vSCT.clear(); //Delete pending messages
608
609 stats().clear();
610 // reset kill counts
611 kill_tracker_ptr->clear();
613 // reset follower list
614 follower_ids.clear();
615 scent.reset();
616
618 remoteveh_cache = nullptr;
619
620 token_provider_ptr->clear();
621 // back to menu for save loading, new game etc
622}
void clear_zombies()
Redirects to the creature_tracker clear() function.
Definition: game.cpp:5051
void load_world_modfiles(loading_ui &ui)
Loads core data and mods from the active world.
Definition: game.cpp:2945
static void clear_all()
Remove all active missions, used to cleanup on exit and before reloading a new game.
Definition: mission.cpp:127
void reset()
Definition: scent_map.cpp:51
static const string_id< weather_type > & NULL_ID()
Returns a null id whose string_id<T>::is_null() must always return true.
void clear_messages()
Definition: messages.cpp:351
void reset_sounds()
Definition: sounds.cpp:565

References _, achievements_tracker_ptr, active_npc, calendar::before_time_starts, bVMonsterLookFire, character_id, explosion_handler::explosion_queue::clear(), stats_tracker::clear(), mission::clear_all(), Messages::clear_messages(), clear_zombies(), coming_to_stairs, debugmsg, faction_manager_ptr, follower_ids, explosion_handler::get_explosion_queue(), get_weather, kill_tracker_ptr, load_core_data(), load_world_modfiles(), m, new_game, next_mission_id, next_npc_id, weather_manager::nextweather, string_id< weather_type >::NULL_ID(), popup(), QUIT_NO, ui_manager::redraw(), refresh_display(), remoteveh_cache, remoteveh_cache_time, scent_map::reset(), sounds::reset_sounds(), scent, SCT, calendar::set_eternal_season(), calendar::set_season_length(), stats(), timed_events, token_provider_ptr, turnssincelastmon, uquit, scrollingcombattext::vSCT, and weather_manager::weather_id.

Referenced by butcher_submenu(), and quickload().

◆ shared_from()

template<typename T >
template shared_ptr_fast< npc > game::shared_from< npc > ( const T &  critter)

Returns a shared pointer to the given critter (which can be of any of the subclasses of Creature).

The function may return an empty pointer if the given critter is not stored anywhere (e.g. it was allocated on the stack, not stored in the critter_tracker nor in active_npc nor is it u).

Definition at line 4904 of file game.cpp.

4905{
4906 if( static_cast<const Creature *>( &critter ) == static_cast<const Creature *>( &u ) ) {
4907 // u is not stored in a shared_ptr, but it won't go out of scope anyway
4908 return std::dynamic_pointer_cast<T>( u_shared_ptr );
4909 }
4910 if( critter.is_monster() ) {
4911 if( const shared_ptr_fast<monster> mon_ptr = critter_tracker->find( critter.pos() ) ) {
4912 if( static_cast<const Creature *>( mon_ptr.get() ) == static_cast<const Creature *>( &critter ) ) {
4913 return std::dynamic_pointer_cast<T>( mon_ptr );
4914 }
4915 }
4916 }
4917 if( critter.is_npc() ) {
4918 for( auto &cur_npc : active_npc ) {
4919 if( static_cast<const Creature *>( cur_npc.get() ) == static_cast<const Creature *>( &critter ) ) {
4920 return std::dynamic_pointer_cast<T>( cur_npc );
4921 }
4922 }
4923 }
4924 return nullptr;
4925}

References active_npc, critter_tracker, u, and u_shared_ptr.

Referenced by list_monsters(), mon_info_update(), and validate_mounted_npcs().

◆ shift_destination_preview()

void game::shift_destination_preview ( const point delta)

Definition at line 12582 of file game.cpp.

12583{
12584 for( tripoint &p : destination_preview ) {
12585 p += delta;
12586 }
12587}

References destination_preview.

◆ shift_monsters()

void game::shift_monsters ( const tripoint shift)
private

Shift all active monsters, the shift vector is the number of shifted submaps.

Monsters that are outside of the reality bubble after shifting are despawned. Note on z-levels: this works with vertical shifts, but currently all monsters are despawned upon a vertical shift.

Definition at line 11587 of file game.cpp.

11588{
11589 // If either shift argument is non-zero, we're shifting.
11590 if( shift == tripoint_zero ) {
11591 return;
11592 }
11593 for( monster &critter : all_monsters() ) {
11594 if( shift.xy() != point_zero ) {
11595 critter.shift( shift.xy() );
11596 }
11597
11598 if( m.inbounds( critter.pos() ) && ( shift.z == 0 || m.has_zlevels() ) ) {
11599 // We're inbounds, so don't despawn after all.
11600 // No need to shift Z-coordinates, they are absolute
11601 continue;
11602 }
11603 // Either a vertical shift or the critter is now outside of the reality bubble,
11604 // anyway: it must be saved and removed.
11605 despawn_monster( critter );
11606 }
11607 // The order in which zombies are shifted may cause zombies to briefly exist on
11608 // the same square. This messes up the mon_at cache, so we need to rebuild it.
11609 critter_tracker->rebuild_cache();
11610}

References all_monsters(), critter_tracker, despawn_monster(), map::has_zlevels(), map::inbounds(), m, point_zero, tripoint_zero, tripoint::xy(), and tripoint::z.

Referenced by update_map(), vertical_move(), and vertical_shift().

◆ slip_down()

bool game::slip_down ( )

Checks if player is able to successfully climb to/from some terrain and not slip down.

Returns
whether player has slipped down
Dexterity decreases chances of slipping while climbing

Definition at line 12589 of file game.cpp.

12590{
12591 ///\EFFECT_DEX decreases chances of slipping while climbing
12592 int climb = u.dex_cur;
12593 if( u.has_trait( trait_BADKNEES ) ) {
12594 climb = climb / 2;
12595 }
12596 if( one_in( climb ) ) {
12597 add_msg( m_bad, _( "You slip while climbing and fall down again." ) );
12598 if( climb <= 1 ) {
12599 add_msg( m_bad, _( "Climbing is impossible in your current state." ) );
12600 }
12601 return true;
12602 }
12603 return false;
12604}
static const trait_id trait_BADKNEES("BADKNEES")

References _, add_msg(), Character::dex_cur, Character::has_trait(), m_bad, one_in(), trait_BADKNEES, and u.

◆ spawn_hallucination()

bool game::spawn_hallucination ( const tripoint p)

Spawns a hallucination at a determined position.

Attempts to spawn a hallucination at given location.

Returns false if the hallucination couldn't be spawned for whatever reason, such as a monster already in the target square.

Returns
Whether or not a hallucination was successfully spawned.

Definition at line 5062 of file game.cpp.

5063{
5064 if( one_in( 100 ) ) {
5065 shared_ptr_fast<npc> tmp = make_shared_fast<npc>();
5066 tmp->normalize();
5067 tmp->randomize( NC_HALLU );
5068 tmp->spawn_at_precise( { get_levx(), get_levy() }, p );
5069 if( !critter_at( p, true ) ) {
5071 load_npcs();
5072 return true;
5073 } else {
5074 return false;
5075 }
5076 }
5077
5079 const shared_ptr_fast<monster> phantasm = make_shared_fast<monster>( mt );
5080 phantasm->hallucination = true;
5081 phantasm->spawn( p );
5082
5083 //Don't attempt to place phantasms inside of other creatures
5084 if( !critter_at( phantasm->pos(), true ) ) {
5085 return critter_tracker->add( phantasm );
5086 } else {
5087 return false;
5088 }
5089}
mtype_id get_valid_hallucination() const
static MonsterGenerator & generator()
npc_class_id NC_HALLU("NC_HALLU")

References critter_at(), critter_tracker, MonsterGenerator::generator(), get_levx(), get_levy(), MonsterGenerator::get_valid_hallucination(), overmapbuffer::insert_npc(), load_npcs(), NC_HALLU, one_in(), and overmap_buffer.

◆ spell_events_subscriber()

spell_events & game::spell_events_subscriber ( )

Definition at line 3106 of file game.cpp.

3107{
3108 return *spell_events_ptr;
3109}

References spell_events_ptr.

◆ start_calendar()

void game::start_calendar ( )

Definition at line 12151 of file game.cpp.

12152{
12153 const bool scen_season = scen->has_flag( "SPR_START" ) || scen->has_flag( "SUM_START" ) ||
12154 scen->has_flag( "AUT_START" ) || scen->has_flag( "WIN_START" ) ||
12155 scen->has_flag( "SUM_ADV_START" );
12156
12158 if( scen_season ) {
12159 // Configured starting date overridden by scenario, calendar_config.start is left as Spring 1
12161 get_option<int>( "INITIAL_TIME" );
12162 calendar_config._start_of_game = calendar::turn_zero + 1_hours * get_option<int>( "INITIAL_TIME" );
12163 if( scen->has_flag( "SPR_START" ) ) {
12165 } else if( scen->has_flag( "SUM_START" ) ) {
12168 } else if( scen->has_flag( "AUT_START" ) ) {
12171 } else if( scen->has_flag( "WIN_START" ) ) {
12174 } else if( scen->has_flag( "SUM_ADV_START" ) ) {
12177 } else {
12178 debugmsg( "The Unicorn" );
12179 }
12180 } else {
12181 // No scenario, so use the starting date+time configured in world options
12182 int initial_days = get_option<int>( "INITIAL_DAY" );
12183 if( initial_days == -1 ) {
12184 // 0 - 363 for a 91 day season
12185 initial_days = rng( 0, get_option<int>( "SEASON_LENGTH" ) * 4 - 1 );
12186 }
12188
12189 // Determine the season based off how long the seasons are set to be
12190 // First take the number of season elapsed up to the starting date, then mod by 4 to get the season of the current year
12191 const int season_number = ( initial_days / get_option<int>( "SEASON_LENGTH" ) ) % 4;
12192 if( season_number == 0 ) {
12194 } else if( season_number == 1 ) {
12196 } else if( season_number == 2 ) {
12198 } else {
12200 }
12201
12203 + 1_hours * get_option<int>( "INITIAL_TIME" )
12204 + 1_days * get_option<int>( "SPAWN_DELAY" );
12205 }
12206
12208}
@ WINTER
Definition: calendar.h:21
@ AUTUMN
Definition: calendar.h:20
@ SUMMER
Definition: calendar.h:19
@ SPRING
Definition: calendar.h:18
time_duration season_length() const
Definition: calendar.h:569
const scenario * scen
Definition: game.h:1030
bool has_flag(const std::string &flag) const
Such as a seasonal start, fiery start, surrounded start, etc.
Definition: scenario.cpp:439

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, AUTUMN, calendar::config, debugmsg, scenario::has_flag(), rng(), scen, calendar_config::season_length(), SPRING, SUMMER, calendar::turn, calendar::turn_zero, and WINTER.

Referenced by start_game().

◆ start_game()

bool game::start_game ( )
private

Definition at line 647 of file game.cpp.

648{
649 if( !gamemode ) {
650 gamemode = std::make_unique<special_game>();
651 }
652
653 seed = rng_bits();
654 new_game = true;
657 safe_mode = ( get_option<bool>( "SAFEMODE" ) ? SAFE_MODE_ON : SAFE_MODE_OFF );
658 mostseen = 0; // ...and mostseen is 0, we haven't seen any monsters yet.
660
662
665 popup.message( "%s", _( "Please wait as we build your world" ) );
668
669 load_master();
670 u.setID( assign_npc_id() ); // should be as soon as possible, but *after* load_master
671
675 do {
676 omtstart = start_loc.find_player_initial_location();
677 if( omtstart == overmap::invalid_tripoint ) {
678 if( query_yn(
679 _( "Try again?\n\nIt may require several attempts until the game finds a valid starting location." ) ) ) {
682 } else {
683 return false;
684 }
685 }
686 } while( omtstart == overmap::invalid_tripoint );
687
688 start_loc.prepare_map( omtstart );
689
690 // Place vehicles spawned by scenario or profession, has to be placed very early to avoid bugs.
691 if( u.starting_vehicle &&
692 !place_vehicle_nearby( u.starting_vehicle, omtstart.xy(), 0, 30,
693 std::vector<std::string> {} ) ) {
694 debugmsg( "could not place starting vehicle" );
695 }
696
697 if( scen->has_map_extra() ) {
698 // Map extras can add monster spawn points and similar and should be done before the main
699 // map is loaded.
700 start_loc.add_map_extra( omtstart, scen->get_map_extra() );
701 }
702
703 // TODO: fix point types
704 tripoint lev = project_to<coords::sm>( omtstart ).raw();
705 // The player is centered in the map, but lev[xyz] refers to the top left point of the map
706 lev.x -= HALF_MAPSIZE;
707 lev.y -= HALF_MAPSIZE;
708 load_map( lev );
709
712 // Do this after the map cache has been built!
713 start_loc.place_player( u );
714 // ...but then rebuild it, because we want visibility cache to avoid spawning monsters in sight
717 // Start the overmap with out immediate neighborhood visible, this needs to be after place_player
719 get_option<int>( "DISTANCE_INITIAL_VISIBILITY" ), 0 );
720
721 u.moves = 0;
722 u.process_turn(); // process_turn adds the initial move points
726 u.next_climate_control_check = calendar::before_time_starts; // Force recheck at startup
728
729 //Reset character safe mode/pickup rules
734
735 //Put some NPCs in there!
736 if( get_option<std::string>( "STARTING_NPC" ) == "always" ||
737 ( get_option<std::string>( "STARTING_NPC" ) == "scenario" &&
738 !g->scen->has_flag( "LONE_START" ) ) ) {
740 }
741 //Load NPCs. Set nearby npcs to active.
742 load_npcs();
743 // Spawn the monsters
744 const bool spawn_near =
745 get_option<bool>( "BLACK_ROAD" ) || g->scen->has_flag( "SUR_START" );
746 // Surrounded start ones
747 if( spawn_near ) {
748 start_loc.surround_with_monsters( omtstart, mongroup_id( "GROUP_ZOMBIE" ), 70 );
749 }
750
751 m.spawn_monsters( !spawn_near ); // Static monsters
752
753 // Make sure that no monsters are near the player
754 // This can happen in lab starts
755 if( !spawn_near ) {
756 for( monster &critter : all_monsters() ) {
757 if( rl_dist( critter.pos(), u.pos() ) <= 5 ||
758 m.clear_path( critter.pos(), u.pos(), 40, 1, 100 ) ) {
759 remove_zombie( critter );
760 }
761 }
762 }
763
764 //Create mutation_category_level
766 //Calculate mutation drench protection stats
769 if( scen->has_flag( "FIRE_START" ) ) {
770 start_loc.burn( omtstart, 3, 3 );
771 }
772 if( scen->has_flag( "INFECTED" ) ) {
774 }
775 if( scen->has_flag( "BAD_DAY" ) ) {
776 u.add_effect( effect_flu, 1000_minutes );
777 u.add_effect( effect_drunk, 270_minutes );
778 u.add_morale( MORALE_FEELING_BAD, -100, -100, 50_minutes, 50_minutes );
779 }
780 if( scen->has_flag( "HELI_CRASH" ) ) {
781 start_loc.handle_heli_crash( u );
782 bool success = false;
783 for( auto v : m.get_vehicles() ) {
784 std::string name = v.v->type.str();
785 std::string search = std::string( "helicopter" );
786 if( name.find( search ) != std::string::npos ) {
787 for( const vpart_reference &vp : v.v->get_any_parts( VPFLAG_CONTROLS ) ) {
788 const tripoint pos = vp.pos();
789 u.setpos( pos );
790
791 // Delete the items that would have spawned here from a "corpse"
792 for( auto sp : v.v->parts_at_relative( vp.mount(), true ) ) {
793 vehicle_stack here = v.v->get_items( sp );
794
795 for( auto iter = here.begin(); iter != here.end(); ) {
796 iter = here.erase( iter );
797 }
798 }
799
800 auto mons = critter_tracker->find( pos );
801 if( mons != nullptr ) {
802 critter_tracker->remove( *mons );
803 }
804
805 success = true;
806 break;
807 }
808 if( success ) {
809 v.v->name = "Bird Wreckage";
810 break;
811 }
812 }
813 }
814 }
815 if( scen->has_flag( "BORDERED" ) ) {
816 overmap &starting_om = get_cur_om();
817 for( int z = -OVERMAP_DEPTH; z <= OVERMAP_HEIGHT; z++ ) {
818 starting_om.place_special_forced( overmap_special_id( "world" ), { 0, 0, z },
820 }
821
822 }
823 for( auto &e : u.inv_dump() ) {
824 e->set_owner( g->u );
825 }
826 // Now that we're done handling coordinates, ensure the player's submap is in the center of the map
827 update_map( u );
828 // Profession pets
829 for( const mtype_id &elem : u.starting_pets ) {
830 if( monster *const mon = place_critter_around( elem, u.pos(), 5 ) ) {
831 mon->friendly = -1;
832 mon->add_effect( effect_pet, 1_turns, num_bp );
833 } else {
834 add_msg( m_debug, "cannot place starting pet, no space!" );
835 }
836 }
837 // Assign all of this scenario's missions to the player.
838 for( const mission_type_id &m : scen->missions() ) {
839 const auto mission = mission::reserve_new( m, character_id() );
840 mission->assign( u );
841 }
842
843 g->events().send<event_type::game_start>( u.getID() );
844 return true;
845}
body_part random_body_part(bool main_parts_only)
Returns a random body_part token.
Definition: bodypart.cpp:364
bool last_climate_control_ret
Definition: character.h:2220
void drench_mut_calc()
Recalculates mutation drench protection for all bodyparts (ignored/good/neutral stats)
Definition: character.cpp:7960
void set_stamina(int new_stamina)
Definition: character.cpp:7222
time_point next_climate_control_check
Definition: character.h:2219
int get_stamina_max() const
Definition: character.cpp:7213
void set_highest_cat_level()
Recalculates mutation_category_level[] values for the player.
Definition: character.cpp:7937
void default_initialize()
Perform default initialization.
Definition: auto_note.cpp:101
void start_calendar()
Definition: game.cpp:12151
void create_starting_npcs()
Definition: game.cpp:973
overmap & get_cur_om() const
The overmap which contains the center submap of the reality bubble.
Definition: game.cpp:12449
vehicle * place_vehicle_nearby(const vproto_id &id, const point_abs_omt &origin, int min_distance, int max_distance, const std::vector< std::string > &omt_search_types={})
Definition: game.cpp:847
bool clear_path(const tripoint &f, const tripoint &t, int range, int cost_min, int cost_max) const
Check whether there's a direct line of sight between F and T with the additional movecost restraints.
Definition: map.cpp:6376
static mission * reserve_new(const mission_type_id &type, const character_id &npc_id)
Create a new mission of the given type and assign it to the given npc.
Definition: mission.cpp:64
void assign(avatar &u)
Assigns the mission to the player.
Definition: mission.cpp:210
void place_special_forced(const overmap_special_id &special_id, const tripoint_om_omt &p, om_direction::type dir)
Definition: overmap.cpp:2163
bool reveal(const point_abs_omt &center, int radius, int z)
Mark a square area around center on Z-level z as seen.
bool random_start_location
Definition: player.h:644
vproto_id starting_vehicle
Definition: player.h:656
std::vector< mtype_id > starting_pets
Definition: player.h:657
start_location_id start_location
Definition: player.h:645
void clear_character_rules()
bool has_map_extra() const
Definition: scenario.cpp:454
const std::string & get_map_extra() const
Definition: scenario.cpp:458
const std::vector< mission_type_id > & missions() const
Definition: scenario.cpp:462
start_location_id random_start_location() const
Definition: scenario.cpp:232
void burn(const tripoint_abs_omt &omtstart, size_t count, int rad) const
Burn random terrain / furniture with FLAMMABLE or FLAMMABLE_ASH tag.
void surround_with_monsters(const tripoint_abs_omt &omtstart, const mongroup_id &type, float expected_points) const
Adds surround start monsters.
void prepare_map(const tripoint_abs_omt &omtstart) const
Initialize the map at players start location using prepare_map.
void place_player(player &u) const
Place the player somewhere in the reality bubble (g->m).
void handle_heli_crash(player &u) const
tripoint_abs_omt find_player_initial_location() const
Find a suitable start location on the overmap.
void add_map_extra(const tripoint_abs_omt &omtstart, const std::string &map_extra) const
Adds a map extra, see map_extras.h and map_extras.cpp.
const T & obj() const
Returns the actual object this id refers to.
Definition: achievement.cpp:58
iterator erase(const_iterator it) override
Definition: vehicle.cpp:230
static const efftype_id effect_drunk("drunk")
static const efftype_id effect_infected("infected")
static const efftype_id effect_accumulated_mutagen("accumulated_mutagen")
static const efftype_id effect_flu("flu")
static constexpr int SPRING_TEMPERATURE
Base starting spring temperature in F used for climate, weather and temperature calculation.
void update_weather()
Definition: weather.cpp:1056
const morale_type MORALE_FEELING_BAD("morale_feeling_bad")
static bool search(const ui_adaptor &om_ui, tripoint_abs_omt &curs, const tripoint_abs_omt &orig)
unsigned int rng_bits()
Definition: rng.cpp:12
string_id< overmap_special > overmap_special_id
Definition: type_id.h:127
string_id< MonsterGroup > mongroup_id
Definition: type_id.h:98
@ VPFLAG_CONTROLS
Definition: veh_type.h:41

References _, Creature::add_effect(), start_location::add_map_extra(), Character::add_morale(), add_msg(), all_monsters(), mission::assign(), assign_npc_id(), calendar::before_time_starts, item_stack::begin(), map::build_map_cache(), start_location::burn(), character_id, auto_notes::auto_note_settings::clear(), overmapbuffer::clear(), auto_pickup::player_settings::clear_character_rules(), safemode::clear_character_rules(), map::clear_path(), create_starting_npcs(), critter_tracker, debugmsg, auto_notes::auto_note_settings::default_initialize(), Character::drench_mut_calc(), effect_accumulated_mutagen, effect_drunk, effect_flu, effect_infected, effect_pet, item_stack::end(), vehicle_stack::erase(), start_location::find_player_initial_location(), g, game_start, gamemode, get_auto_notes_settings(), get_auto_pickup(), get_cur_om(), get_levz(), scenario::get_map_extra(), get_safemode(), Character::get_stamina_max(), map::get_vehicles(), get_weather, Character::getID(), Character::global_omt_location(), HALF_MAPSIZE, start_location::handle_heli_crash(), scenario::has_flag(), scenario::has_map_extra(), init_autosave(), Character::inv_dump(), overmap::invalid_tripoint, map::invalidate_map_cache(), Character::last_climate_control_ret, safemode::load_global(), load_map(), load_master(), load_npcs(), m, m_debug, MAPBUFFER, scenario::missions(), MORALE_FEELING_BAD, mostseen, Creature::moves, om_direction::name(), new_game, Character::next_climate_control_check, weather_manager::nextweather, om_direction::north, num_bp, string_id< T >::obj(), overmap_buffer, OVERMAP_DEPTH, OVERMAP_HEIGHT, place_critter_around(), start_location::place_player(), overmap::place_special_forced(), place_vehicle_nearby(), popup(), Character::pos(), start_location::prepare_map(), player::process_turn(), query_yn(), random_body_part(), player::random_start_location, scenario::random_start_location(), ui_manager::redraw(), refresh_display(), remove_zombie(), mission::reserve_new(), mapbuffer::reset(), overmapbuffer::reveal(), rl_dist(), rng_bits(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, scen, overmap_ui::search(), seed, Character::set_highest_cat_level(), Character::set_stamina(), Character::setID(), Character::setpos(), map::spawn_monsters(), SPRING_TEMPERATURE, start_calendar(), player::start_location, player::starting_pets, player::starting_vehicle, behavior::success, start_location::surround_with_monsters(), weather_manager::temperature, calendar::turn, u, update_map(), weather_manager::update_weather(), VPFLAG_CONTROLS, tripoint::x, coords::coord_point< Point, Origin, Scale >::xy(), and tripoint::y.

◆ start_hauling()

void game::start_hauling ( const tripoint pos)

Definition at line 10950 of file game.cpp.

10951{
10952 // Find target items and quantities thereof for the new activity
10953 std::vector<item_location> target_items;
10954 std::vector<int> quantities;
10955
10956 map_stack items = m.i_at( pos );
10957 for( item &it : items ) {
10958 // Liquid cannot be picked up
10959 if( it.made_of( LIQUID ) ) {
10960 continue;
10961 }
10962 target_items.emplace_back( map_cursor( pos ), &it );
10963 // Quantity of 0 means move all
10964 quantities.push_back( 0 );
10965 }
10966
10967 if( target_items.empty() ) {
10968 // Nothing to haul
10969 return;
10970 }
10971
10972 // Whether the destination is inside a vehicle (not supported)
10973 const bool to_vehicle = false;
10974 // Destination relative to the player
10975 const tripoint relative_destination{};
10976
10978 target_items,
10979 quantities,
10980 to_vehicle,
10981 relative_destination
10982 ) ) );
10983}

References Character::assign_activity(), map::i_at(), LIQUID, m, and u.

Referenced by vertical_move(), and walk_move().

◆ stats()

stats_tracker & game::stats ( )

Definition at line 3096 of file game.cpp.

3097{
3098 return *stats_tracker_ptr;
3099}

References stats_tracker_ptr.

Referenced by death_screen(), handle_action(), setup(), and win().

◆ swap_critters()

bool game::swap_critters ( Creature a,
Creature b 
)

Swaps positions of two creatures.

Definition at line 5091 of file game.cpp.

5092{
5093 if( &a == &b ) {
5094 // No need to do anything, but print a debugmsg anyway
5095 debugmsg( "Tried to swap %s with itself", a.disp_name() );
5096 return true;
5097 }
5098 if( critter_at( a.pos() ) != &a ) {
5099 debugmsg( "Tried to swap when it would cause a collision between %s and %s.",
5100 b.disp_name(), critter_at( a.pos() )->disp_name() );
5101 return false;
5102 }
5103 if( critter_at( b.pos() ) != &b ) {
5104 debugmsg( "Tried to swap when it would cause a collision between %s and %s.",
5105 a.disp_name(), critter_at( b.pos() )->disp_name() );
5106 return false;
5107 }
5108 // Simplify by "sorting" the arguments
5109 // Only the first argument can be u
5110 // If swapping player/npc with a monster, monster is second
5111 bool a_first = a.is_player() ||
5112 ( a.is_npc() && !b.is_player() );
5113 Creature &first = a_first ? a : b;
5114 Creature &second = a_first ? b : a;
5115 // Possible options:
5116 // both first and second are monsters
5117 // second is a monster, first is a player or an npc
5118 // first is a player, second is an npc
5119 // both first and second are npcs
5120 if( first.is_monster() ) {
5121 monster *m1 = dynamic_cast< monster * >( &first );
5122 monster *m2 = dynamic_cast< monster * >( &second );
5123 if( m1 == nullptr || m2 == nullptr || m1 == m2 ) {
5124 debugmsg( "Couldn't swap two monsters" );
5125 return false;
5126 }
5127
5128 critter_tracker->swap_positions( *m1, *m2 );
5129 return true;
5130 }
5131
5132 player *u_or_npc = dynamic_cast< player * >( &first );
5133 player *other_npc = dynamic_cast< player * >( &second );
5134
5135 if( u_or_npc->in_vehicle ) {
5136 m.unboard_vehicle( u_or_npc->pos() );
5137 }
5138
5139 if( other_npc && other_npc->in_vehicle ) {
5140 m.unboard_vehicle( other_npc->pos() );
5141 }
5142
5143 tripoint temp = second.pos();
5144 second.setpos( first.pos() );
5145
5146 if( first.is_player() ) {
5147 walk_move( temp );
5148 } else {
5149 first.setpos( temp );
5150 if( m.veh_at( u_or_npc->pos() ).part_with_feature( VPFLAG_BOARDABLE, true ) ) {
5151 m.board_vehicle( u_or_npc->pos(), u_or_npc );
5152 }
5153 }
5154
5155 if( other_npc && m.veh_at( other_npc->pos() ).part_with_feature( VPFLAG_BOARDABLE, true ) ) {
5156 m.board_vehicle( other_npc->pos(), other_npc );
5157 }
5158 return true;
5159}
virtual bool is_monster() const
Definition: creature.h:101
virtual bool is_player() const
Definition: creature.h:92
virtual void setpos(const tripoint &pos)=0
bool walk_move(const tripoint &dest, bool via_ramp=false)
Definition: game.cpp:9330
@ VPFLAG_BOARDABLE
Definition: veh_type.h:39

References a, b, map::board_vehicle(), critter_at(), critter_tracker, debugmsg, Character::in_vehicle, Creature::is_monster(), Creature::is_player(), m, optional_vpart_position::part_with_feature(), Creature::pos(), Character::pos(), second, Creature::setpos(), map::unboard_vehicle(), map::veh_at(), VPFLAG_BOARDABLE, and walk_move().

Referenced by npc_menu().

◆ take_screenshot() [1/2]

bool game::take_screenshot ( ) const

Saves a screenshot of the current viewport, as a PNG file.

Filesystem location is derived from the current world and character.

Note
: Only works for SDL/TILES (otherwise the function returns false). A window (more precisely, a viewport) must already exist and the SDL renderer must be valid.
Returns
true if the screenshot generation was successful, false otherwise.

Definition at line 7428 of file game.cpp.

7429{
7430 popup( _( "This binary was not compiled with tiles support." ) );
7431 return false;
7432}

References _, and popup().

Referenced by do_turn().

◆ take_screenshot() [2/2]

bool game::take_screenshot ( const std::string &  file_path) const

Saves a screenshot of the current viewport, as a PNG file, to the given location.

Parameters
file_pathA full path to the file where the screenshot should be saved.
Note
: Only works for SDL/TILES (otherwise the function returns false). A window (more precisely, a viewport) must already exist and the SDL renderer must be valid.
Returns
true if the screenshot generation was successful, false otherwise.

Definition at line 7422 of file game.cpp.

7423{
7424 popup( _( "This binary was not compiled with tiles support." ) );
7425 return false;
7426}

References _, and popup().

◆ temp_exit_fullscreen()

void game::temp_exit_fullscreen ( )

Definition at line 538 of file game.cpp.

539{
540 if( fullscreen ) {
541 was_fullscreen = true;
543 } else {
544 was_fullscreen = false;
545 }
546}

References fullscreen, toggle_fullscreen(), and was_fullscreen.

Referenced by list_items_monsters(), and look_around().

◆ toggle_debug_hour_timer()

void game::toggle_debug_hour_timer ( )

Definition at line 11758 of file game.cpp.

11759{
11761}

References game::debug_hour_timer::toggle().

Referenced by handle_action(), and look_around().

◆ toggle_fullscreen()

void game::toggle_fullscreen ( )

Definition at line 500 of file game.cpp.

501{
502#if !defined(TILES)
505#else
506 toggle_fullscreen_window();
507#endif
508}

References fullscreen, and mark_main_ui_adaptor_resize().

Referenced by handle_action(), reenter_fullscreen(), and temp_exit_fullscreen().

◆ toggle_pixel_minimap()

void game::toggle_pixel_minimap ( )

Definition at line 510 of file game.cpp.

511{
512#if defined(TILES)
514 clear_window_area( w_pixel_minimap );
515 }
518#endif // TILES
519}

References mark_main_ui_adaptor_resize(), pixel_minimap_option, and w_pixel_minimap.

Referenced by handle_action(), and look_around().

◆ try_get_left_click_action()

bool game::try_get_left_click_action ( action_id act,
const tripoint mouse_target 
)
private

Definition at line 2618 of file game.cpp.

2619{
2620 bool new_destination = true;
2621 if( !destination_preview.empty() ) {
2622 auto &final_destination = destination_preview.back();
2623 if( final_destination.x == mouse_target.x && final_destination.y == mouse_target.y ) {
2624 // Second click
2625 new_destination = false;
2627 destination_preview.clear();
2629 if( act == ACTION_NULL ) {
2630 // Something went wrong
2632 return false;
2633 }
2634 }
2635 }
2636
2637 if( new_destination ) {
2639 u.get_path_avoid() );
2640 return false;
2641 }
2642
2643 return true;
2644}

References act, ACTION_NULL, Character::clear_destination(), destination_preview, Character::get_next_auto_move_direction(), Character::get_path_avoid(), Character::get_pathfinding_settings(), m, Character::pos(), map::route(), Character::set_destination(), u, tripoint::x, and tripoint::y.

Referenced by handle_action().

◆ try_get_right_click_action()

bool game::try_get_right_click_action ( action_id act,
const tripoint mouse_target 
)
private

Definition at line 2646 of file game.cpp.

2647{
2648 const bool cleared_destination = !destination_preview.empty();
2650 destination_preview.clear();
2651
2652 if( cleared_destination ) {
2653 // Produce no-op if auto-move had just been cleared on this action
2654 // e.g. from a previous single left mouse click. This has the effect
2655 // of right-click canceling an auto-move before it is initiated.
2656 return false;
2657 }
2658
2659 const bool is_adjacent = square_dist( mouse_target.xy(), point( u.posx(), u.posy() ) ) <= 1;
2660 const bool is_self = square_dist( mouse_target.xy(), point( u.posx(), u.posy() ) ) <= 0;
2661 if( const monster *const mon = critter_at<monster>( mouse_target ) ) {
2662 if( !u.sees( *mon ) ) {
2663 add_msg( _( "Nothing relevant here." ) );
2664 return false;
2665 }
2666
2667 if( !u.weapon.is_gun() ) {
2668 add_msg( m_info, _( "You are not wielding a ranged weapon." ) );
2669 return false;
2670 }
2671
2672 // TODO: Add weapon range check. This requires weapon to be reloaded.
2673
2674 act = ACTION_FIRE;
2675 } else if( is_adjacent &&
2676 m.close_door( tripoint( mouse_target.xy(), u.posz() ), !m.is_outside( u.pos() ),
2677 true ) ) {
2678 act = ACTION_CLOSE;
2679 } else if( is_self ) {
2681 } else if( is_adjacent ) {
2683 } else {
2684 add_msg( _( "Nothing relevant here." ) );
2685 return false;
2686 }
2687
2688 return true;
2689}
bool close_door(const tripoint &p, bool inside, bool check_only)
Definition: map.cpp:3953
static bool is_adjacent(const monster &z, const Creature &target)

References _, act, ACTION_CLOSE, ACTION_EXAMINE, ACTION_FIRE, ACTION_PICKUP, add_msg(), Character::clear_destination(), map::close_door(), destination_preview, is_adjacent(), item::is_gun(), map::is_outside(), m, m_info, Character::pos(), Character::posx(), Character::posy(), Character::posz(), Character::sees(), square_dist(), u, Character::weapon, and tripoint::xy().

Referenced by handle_action().

◆ unload()

bool game::unload ( item_location  loc)

Definition at line 9026 of file game.cpp.

9027{
9028 return u.unload( loc );
9029}
bool unload(item_location loc)
Definition: player.cpp:2942

References u, and player::unload().

Referenced by inventory_item_menu().

◆ unload_npcs()

void game::unload_npcs ( )
private

Unloads all NPCs.

If you call this you must later call load_npcs, lest caches get rather confused. The tests used to call this a lot when they shouldn't. It is now private to reduce the chance of similar problems in the future.

Definition at line 951 of file game.cpp.

952{
953 for( const auto &npc : active_npc ) {
954 npc->on_unload();
955 }
956
957 active_npc.clear();
958}
void on_unload()
Do some cleanup and caching as npc is being unloaded from map.
Definition: npc.cpp:2642

References active_npc, and npc::on_unload().

Referenced by place_player_overmap(), and reload_npcs().

◆ unserialize()

void game::unserialize ( std::istream &  fin)

Definition at line 167 of file savegame.cpp.

168{
169 chkversion( fin );
170 int tmpturn = 0;
171 int tmpcalstart = 0;
172 int tmprun = 0;
173 tripoint lev;
174 point com;
175 JsonIn jsin( fin );
176 try {
177 JsonObject data = jsin.get_object();
178
179 data.read( "turn", tmpturn );
180 data.read( "calendar_start", tmpcalstart );
182 calendar_config._initial_season = static_cast<season_type>( data.get_int( "initial_season",
183 static_cast<int>( SPRING ) ) );
184 // 0.E stable
185 if( savegame_loading_version < 26 ) {
186 tmpturn *= 6;
187 tmpcalstart *= 6;
188 }
191 tmpcalstart );
192
193 if( !data.read( "game_start", calendar_config._start_of_game ) ) {
195 }
196
197 data.read( "auto_travel_mode", auto_travel_mode );
198 data.read( "run_mode", tmprun );
199 data.read( "mostseen", mostseen );
200 data.read( "levx", lev.x );
201 data.read( "levy", lev.y );
202 data.read( "levz", lev.z );
203 data.read( "om_x", com.x );
204 data.read( "om_y", com.y );
205
206 load_map( tripoint( lev.x + com.x * OMAPX * 2, lev.y + com.y * OMAPY * 2, lev.z ) );
207
208 safe_mode = static_cast<safe_mode_type>( tmprun );
209 if( get_option<bool>( "SAFEMODE" ) && safe_mode == SAFE_MODE_OFF ) {
211 }
212
213 std::string linebuff;
214 std::string linebuf;
215 if( data.read( "grscent", linebuf ) && data.read( "typescent", linebuff ) ) {
216 scent.deserialize( linebuf );
217 scent.deserialize( linebuff, true );
218 } else {
219 scent.reset();
220 }
221 data.read( "active_monsters", *critter_tracker );
222
223 coming_to_stairs.clear();
224 for( auto elem : data.get_array( "stair_monsters" ) ) {
225 monster stairtmp;
226 elem.read( stairtmp );
227 coming_to_stairs.push_back( stairtmp );
228 }
229
230 if( data.has_object( "kill_tracker" ) ) {
231 data.read( "kill_tracker", *kill_tracker_ptr );
232 } else {
233 // Legacy support for when kills were stored directly in game
234 std::map<mtype_id, int> kills;
235 std::vector<std::string> npc_kills;
236 for( const JsonMember member : data.get_object( "kills" ) ) {
237 kills[mtype_id( member.name() )] = member.get_int();
238 }
239
240 for( const std::string npc_name : data.get_array( "npc_kills" ) ) {
241 npc_kills.push_back( npc_name );
242 }
243
244 kill_tracker_ptr->reset( kills, npc_kills );
245 }
246
247 data.read( "player", u );
248 data.read( "stats_tracker", *stats_tracker_ptr );
249 data.read( "achievements_tracker", *achievements_tracker_ptr );
250 data.read( "token_provider", token_provider_ptr );
251 Messages::deserialize( data );
252
253 } catch( const JsonError &jsonerr ) {
254 debugmsg( "Bad save json\n%s", jsonerr.c_str() );
255 return;
256 }
257}
season_type
Real world seasons.
Definition: calendar.h:17
Represents a member of a JsonObject.
Definition: json.h:1249
JsonObject get_object(const std::string &name) const
Definition: json.cpp:361
bool has_object(const std::string &name) const
Definition: json.cpp:425
JsonArray get_array(const std::string &name) const
Definition: json.cpp:332
int get_int(const std::string &name) const
Definition: json.cpp:282
bool read(const std::string &name, T &t, bool throw_on_error=true) const
Definition: json.h:944
void deserialize(const std::string &data, bool is_type=false)
Definition: savegame.cpp:259
safe_mode_type
Definition: game.h:76
static constexpr int OMAPY
static constexpr int OMAPX
Size of the overmap.
void deserialize(const JsonObject &json)
Definition: messages.cpp:330
std::string member
Definition: mapgen.cpp:402
static void chkversion(std::istream &fin)
Definition: savegame.cpp:148
int savegame_loading_version
Definition: savegame.cpp:64

References calendar_config::_initial_season, calendar_config::_start_of_cataclysm, calendar_config::_start_of_game, achievements_tracker_ptr, auto_travel_mode, JsonError::c_str(), chkversion(), coming_to_stairs, calendar::config, critter_tracker, debugmsg, Messages::deserialize(), scent_map::deserialize(), time_duration::from_turns(), JsonObject::get_array(), JsonObject::get_int(), JsonIn::get_object(), JsonObject::get_object(), JsonObject::has_object(), kill_tracker_ptr, load_map(), mapgen_defer::member, mostseen, mtype_id, OMAPX, OMAPY, JsonObject::read(), scent_map::reset(), safe_mode, SAFE_MODE_OFF, SAFE_MODE_ON, savegame_loading_version, scent, SPRING, stats_tracker_ptr, token_provider_ptr, calendar::turn, calendar::turn_zero, u, point::x, tripoint::x, point::y, tripoint::y, and tripoint::z.

Referenced by load().

◆ unserialize_master()

void game::unserialize_master ( std::istream &  fin)

Definition at line 1188 of file savegame.cpp.

1189{
1191 chkversion( fin );
1192 if( savegame_loading_version < 11 ) {
1193 std::unique_ptr<static_popup>popup = std::make_unique<static_popup>();
1194 popup->message(
1195 _( "Cannot find loader for save data in old version %d, attempting to load as current version %d." ),
1199 }
1200 try {
1201 // single-pass parsing example
1202 JsonIn jsin( fin );
1203 jsin.start_object();
1204 while( !jsin.end_object() ) {
1205 std::string name = jsin.get_member_name();
1206 if( name == "next_mission_id" ) {
1207 next_mission_id = jsin.get_int();
1208 } else if( name == "next_npc_id" ) {
1209 next_npc_id.deserialize( jsin );
1210 } else if( name == "active_missions" ) {
1212 } else if( name == "factions" ) {
1213 jsin.read( *faction_manager_ptr );
1214 } else if( name == "seed" ) {
1215 jsin.read( seed );
1216 } else if( name == "weather" ) {
1217 JsonObject w = jsin.get_object();
1218 w.read( "lightning", get_weather().lightning_active );
1219 } else {
1220 // silently ignore anything else
1221 jsin.skip_value();
1222 }
1223 }
1224 } catch( const JsonError &e ) {
1225 debugmsg( "error loading %s: %s", SAVE_MASTER, e.c_str() );
1226 }
1227}
void deserialize(JsonIn &)
static void unserialize_all(JsonIn &jsin)
Definition: savegame.cpp:1178

References _, JsonError::c_str(), chkversion(), debugmsg, character_id::deserialize(), JsonIn::end_object(), faction_manager_ptr, JsonIn::get_int(), JsonIn::get_member_name(), JsonIn::get_object(), get_weather, om_direction::name(), next_mission_id, next_npc_id, popup(), JsonIn::read(), JsonObject::read(), ui_manager::redraw(), refresh_display(), SAVE_MASTER(), savegame_loading_version, savegame_version, seed, JsonIn::skip_value(), JsonIn::start_object(), and mission::unserialize_all().

Referenced by load_master().

◆ update_map() [1/2]

point game::update_map ( int &  x,
int &  y 
)

Definition at line 11218 of file game.cpp.

11219{
11220 point shift;
11221
11222 while( x < HALF_MAPSIZE_X ) {
11223 x += SEEX;
11224 shift.x--;
11225 }
11226 while( x >= HALF_MAPSIZE_X + SEEX ) {
11227 x -= SEEX;
11228 shift.x++;
11229 }
11230 while( y < HALF_MAPSIZE_Y ) {
11231 y += SEEY;
11232 shift.y--;
11233 }
11234 while( y >= HALF_MAPSIZE_Y + SEEY ) {
11235 y -= SEEY;
11236 shift.y++;
11237 }
11238
11239 if( shift == point_zero ) {
11240 // adjust player position
11241 u.setpos( tripoint( x, y, get_levz() ) );
11242 // Update what parts of the world map we can see
11243 // We need this call because even if the map hasn't shifted we may have changed z-level and can now see farther
11244 // TODO: only make this call if we changed z-level
11246 // Not actually shifting the submaps, all the stuff below would do nothing
11247 return point_zero;
11248 }
11249
11250 // this handles loading/unloading submaps that have scrolled on or off the viewport
11251 // NOLINTNEXTLINE(cata-use-named-point-constants)
11252 inclusive_rectangle<point> size_1( point( -1, -1 ), point( 1, 1 ) );
11253 point remaining_shift = shift;
11254 while( remaining_shift != point_zero ) {
11255 point this_shift = clamp( remaining_shift, size_1 );
11256 m.shift( this_shift );
11257 remaining_shift -= this_shift;
11258 }
11259
11260 grid_tracker_ptr->load( m );
11261
11262 // Shift monsters
11263 shift_monsters( tripoint( shift, 0 ) );
11264 const point shift_ms = sm_to_ms_copy( shift );
11265 u.shift_destination( -shift_ms );
11266
11267 // Shift NPCs
11268 for( auto it = active_npc.begin(); it != active_npc.end(); ) {
11269 ( *it )->shift( shift );
11270 if( ( *it )->posx() < 0 - SEEX * 2 || ( *it )->posy() < 0 - SEEX * 2 ||
11271 ( *it )->posx() > SEEX * ( MAPSIZE + 2 ) || ( *it )->posy() > SEEY * ( MAPSIZE + 2 ) ) {
11272 //Remove the npc from the active list. It remains in the overmap list.
11273 ( *it )->on_unload();
11274 it = active_npc.erase( it );
11275 } else {
11276 it++;
11277 }
11278 }
11279
11280 scent.shift( shift_ms );
11281
11282 // Also ensure the player is on current z-level
11283 // get_levz() should later be removed, when there is no longer such a thing
11284 // as "current z-level"
11285 u.setpos( tripoint( x, y, get_levz() ) );
11286
11287 // Only do the loading after all coordinates have been shifted.
11288
11289 // Check for overmap saved npcs that should now come into view.
11290 // Put those in the active list.
11291 load_npcs();
11292
11293 // Make sure map cache is consistent since it may have shifted.
11294 if( m.has_zlevels() ) {
11295 for( int zlev = -OVERMAP_DEPTH; zlev <= OVERMAP_HEIGHT; ++zlev ) {
11296 m.invalidate_map_cache( zlev );
11297 }
11298 } else {
11300 }
11302
11303 // Spawn monsters if appropriate
11304 // This call will generate new monsters in addition to loading, so it's placed after NPC loading
11305 m.spawn_monsters( false ); // Static monsters
11306
11307 // Update what parts of the world map we can see
11309
11310 return shift;
11311}
void shift_destination(const point &shift)
void shift_monsters(const tripoint &shift)
Shift all active monsters, the shift vector is the number of shifted submaps.
Definition: game.cpp:11587
void shift(const point &s)
Shift the map along the vector s.
Definition: map.cpp:6745
void shift(const point &sm_shift)
Definition: scent_map.cpp:82
point sm_to_ms_copy(const point &p)
static constexpr int HALF_MAPSIZE_Y
static constexpr int HALF_MAPSIZE_X

References active_npc, map::build_map_cache(), clamp(), get_levz(), grid_tracker_ptr, HALF_MAPSIZE_X, HALF_MAPSIZE_Y, map::has_zlevels(), map::invalidate_map_cache(), load_npcs(), m, MAPSIZE, OVERMAP_DEPTH, OVERMAP_HEIGHT, point_zero, scent, SEEX, SEEY, Character::setpos(), map::shift(), scent_map::shift(), Character::shift_destination(), shift_monsters(), sm_to_ms_copy(), map::spawn_monsters(), u, update_overmap_seen(), point::x, and point::y.

◆ update_map() [2/2]

point game::update_map ( player p)

Definition at line 11212 of file game.cpp.

11213{
11214 point p2( p.posx(), p.posy() );
11215 return update_map( p2.x, p2.y );
11216}

References Character::posx(), Character::posy(), update_map(), point::x, and point::y.

Referenced by fling_creature(), load(), place_player(), start_game(), update_map(), and vertical_move().

◆ update_overmap_seen()

void game::update_overmap_seen ( )

Definition at line 11313 of file game.cpp.

11314{
11315 const tripoint_abs_omt ompos = u.global_omt_location();
11316 const int dist = u.overmap_sight_range( light_level( u.posz() ) );
11317 const int dist_squared = dist * dist;
11318 // We can always see where we're standing
11319 overmap_buffer.set_seen( ompos, true );
11320 for( const tripoint_abs_omt &p : points_in_radius( ompos, dist ) ) {
11321 const point_rel_omt delta = p.xy() - ompos.xy();
11322 const int h_squared = delta.x() * delta.x() + delta.y() * delta.y();
11323 if( trigdist && h_squared > dist_squared ) {
11324 continue;
11325 }
11326 if( delta == point_rel_omt() ) {
11327 // 1. This case is already handled outside of the loop
11328 // 2. Calculating multiplier would cause division by zero
11329 continue;
11330 }
11331 // If circular distances are enabled, scale overmap distances by the diagonality of the sight line.
11332 point abs_delta = delta.raw().abs();
11333 int max_delta = std::max( abs_delta.x, abs_delta.y );
11334 const float multiplier = trigdist ? std::sqrt( h_squared ) / max_delta : 1;
11335 const std::vector<tripoint_abs_omt> line = line_to( ompos, p );
11336 float sight_points = dist;
11337 for( auto it = line.begin();
11338 it != line.end() && sight_points >= 0; ++it ) {
11339 const oter_id &ter = overmap_buffer.ter( *it );
11340 sight_points -= static_cast<int>( ter->get_see_cost() ) * multiplier;
11341 }
11342 if( sight_points >= 0 ) {
11343 tripoint_abs_omt seen( p );
11344 do {
11345 overmap_buffer.set_seen( seen, true );
11346 --seen.z();
11347 } while( seen.z() >= 0 );
11348 }
11349 }
11350}
bool trigdist
Circular distances.
int overmap_sight_range(int light_level) const
Returns the distance the player can see on the overmap.
Definition: character.cpp:771
constexpr Point & raw()
Definition: coordinates.h:111
void set_seen(const tripoint_abs_omt &p, bool seen=true)
coords::coord_point< point, coords::origin::relative, coords::omt > point_rel_omt
Definition: coordinates.h:478
tripoint_range< Tripoint > points_in_radius(const Tripoint &center, const int radius, const int radiusz=0)
Definition: map_iterator.h:125
unsigned char get_see_cost() const
Definition: omdata.h:230

References oter_t::get_see_cost(), Character::global_omt_location(), light_level(), line(), line_to(), overmap_buffer, Character::overmap_sight_range(), points_in_radius(), Character::posz(), coords::coord_point< Point, Origin, Scale >::raw(), overmapbuffer::set_seen(), overmapbuffer::ter(), trigdist, u, coords::coord_point< Point, Origin, Scale >::x(), point::x, coords::coord_point< Point, Origin, Scale >::xy(), coords::coord_point< Point, Origin, Scale >::y(), point::y, and coords::coord_point< Point, Origin, Scale >::z().

Referenced by place_player_overmap(), and update_map().

◆ update_stair_monsters()

void game::update_stair_monsters ( )
private
Dodge reduces chance of being downed when pushed off the stairs

Definition at line 11365 of file game.cpp.

11366{
11367 // Search for the stairs closest to the player.
11368 std::vector<int> stairx;
11369 std::vector<int> stairy;
11370 std::vector<int> stairdist;
11371
11372 const bool from_below = monstairz < get_levz();
11373
11374 if( coming_to_stairs.empty() ) {
11375 return;
11376 }
11377
11378 if( m.has_zlevels() ) {
11379 debugmsg( "%d monsters coming to stairs on a map with z-levels",
11380 coming_to_stairs.size() );
11381 coming_to_stairs.clear();
11382 }
11383
11384 for( const tripoint &dest : m.points_on_zlevel( u.posz() ) ) {
11385 if( ( from_below && m.has_flag( "GOES_DOWN", dest ) ) ||
11386 ( !from_below && m.has_flag( "GOES_UP", dest ) ) ) {
11387 stairx.push_back( dest.x );
11388 stairy.push_back( dest.y );
11389 stairdist.push_back( rl_dist( dest, u.pos() ) );
11390 }
11391 }
11392 if( stairdist.empty() ) {
11393 return; // Found no stairs?
11394 }
11395
11396 // Find closest stairs.
11397 size_t si = 0;
11398 for( size_t i = 0; i < stairdist.size(); i++ ) {
11399 if( stairdist[i] < stairdist[si] ) {
11400 si = i;
11401 }
11402 }
11403
11404 // Find up to 4 stairs for distance stairdist[si] +1
11405 std::vector<int> nearest;
11406 nearest.push_back( si );
11407 for( size_t i = 0; i < stairdist.size() && nearest.size() < 4; i++ ) {
11408 if( ( i != si ) && ( stairdist[i] <= stairdist[si] + 1 ) ) {
11409 nearest.push_back( i );
11410 }
11411 }
11412 // Randomize the stair choice
11413 si = random_entry_ref( nearest );
11414
11415 // Attempt to spawn zombies.
11416 for( size_t i = 0; i < coming_to_stairs.size(); i++ ) {
11417 point mpos( stairx[si], stairy[si] );
11418 monster &critter = coming_to_stairs[i];
11419 const tripoint dest {
11420 mpos, g->get_levz()
11421 };
11422
11423 // We might be not be visible.
11424 if( ( critter.posx() < 0 - ( MAPSIZE_X ) / 6 ||
11425 critter.posy() < 0 - ( MAPSIZE_Y ) / 6 ||
11426 critter.posx() > ( MAPSIZE_X * 7 ) / 6 ||
11427 critter.posy() > ( MAPSIZE_Y * 7 ) / 6 ) ) {
11428 continue;
11429 }
11430
11431 critter.staircount -= 4;
11432 // Let the player know zombies are trying to come.
11433 if( u.sees( dest ) ) {
11434 std::string dump;
11435 if( critter.staircount > 4 ) {
11436 dump += string_format( _( "You see a %s on the stairs" ), critter.name() );
11437 } else {
11438 if( critter.staircount > 0 ) {
11439 dump += ( from_below ?
11440 //~ The <monster> is almost at the <bottom/top> of the <terrain type>!
11441 string_format( _( "The %1$s is almost at the top of the %2$s!" ),
11442 critter.name(),
11443 m.tername( dest ) ) :
11444 string_format( _( "The %1$s is almost at the bottom of the %2$s!" ),
11445 critter.name(),
11446 m.tername( dest ) ) );
11447 }
11448 }
11449
11450 add_msg( m_warning, dump );
11451 } else {
11453 _( "a sound nearby from the stairs!" ), true, "misc", "stairs_movement" );
11454 }
11455
11456 if( critter.staircount > 0 ) {
11457 continue;
11458 }
11459
11460 if( is_empty( dest ) ) {
11461 critter.spawn( dest );
11462 critter.staircount = 0;
11463 place_critter_at( make_shared_fast<monster>( critter ), dest );
11464 if( u.sees( dest ) ) {
11465 if( !from_below ) {
11466 add_msg( m_warning, _( "The %1$s comes down the %2$s!" ),
11467 critter.name(),
11468 m.tername( dest ) );
11469 } else {
11470 add_msg( m_warning, _( "The %1$s comes up the %2$s!" ),
11471 critter.name(),
11472 m.tername( dest ) );
11473 }
11474 }
11475 coming_to_stairs.erase( coming_to_stairs.begin() + i );
11476 continue;
11477 } else if( u.pos() == dest ) {
11478 // Monster attempts to push player of stairs
11480 int tries = 0;
11481
11482 // the critter is now right on top of you and will attack unless
11483 // it can find a square to push you into with one of his tries.
11484 const int creature_push_attempts = 9;
11485 const int player_throw_resist_chance = 3;
11486
11487 critter.spawn( dest );
11488 while( tries < creature_push_attempts ) {
11489 tries++;
11490 push.x = rng( -1, 1 );
11491 push.y = rng( -1, 1 );
11492 point ipos( mpos + push );
11493 tripoint pos( ipos, get_levz() );
11494 if( ( push.x != 0 || push.y != 0 ) && !critter_at( pos ) &&
11495 critter.can_move_to( pos ) ) {
11496 bool resiststhrow = ( u.is_throw_immune() ) ||
11498 if( resiststhrow && one_in( player_throw_resist_chance ) ) {
11499 u.moves -= 25; // small charge for avoiding the push altogether
11500 add_msg( _( "The %s fails to push you back!" ),
11501 critter.name() );
11502 return; //judo or leg brace prevent you from getting pushed at all
11503 }
11504 // Not accounting for tentacles latching on, so..
11505 // Something is about to happen, lets charge half a move
11506 u.moves -= 50;
11507 if( resiststhrow && ( u.is_throw_immune() ) ) {
11508 //we have a judoka who isn't getting pushed but counterattacking now.
11509 mattack::thrown_by_judo( &critter );
11510 return;
11511 }
11512 std::string msg;
11513 ///\EFFECT_DODGE reduces chance of being downed when pushed off the stairs
11514 if( !( resiststhrow ) && ( u.get_dodge() + rng( 0, 3 ) < 12 ) ) {
11515 // dodge 12 - never get downed
11516 // 11.. avoid 75%; 10.. avoid 50%; 9.. avoid 25%
11517 u.add_effect( effect_downed, 2_turns );
11518 msg = _( "The %s pushed you back hard!" );
11519 } else {
11520 msg = _( "The %s pushed you back!" );
11521 }
11522 add_msg( m_warning, msg.c_str(), critter.name() );
11523 u.setx( u.posx() + push.x );
11524 u.sety( u.posy() + push.y );
11525 return;
11526 }
11527 }
11529 _( "The %s tried to push you back but failed! It attacks you!" ),
11530 critter.name() );
11531 critter.melee_attack( u );
11532 u.moves -= 50;
11533 return;
11534 } else if( monster *const mon_ptr = critter_at<monster>( dest ) ) {
11535 // Monster attempts to displace a monster from the stairs
11536 monster &other = *mon_ptr;
11537 critter.spawn( dest );
11538
11539 // the critter is now right on top of another and will push it
11540 // if it can find a square to push it into inside of his tries.
11541 const int creature_push_attempts = 9;
11542 const int creature_throw_resist = 4;
11543
11544 int tries = 0;
11545 point push2;
11546 while( tries < creature_push_attempts ) {
11547 tries++;
11548 push2.x = rng( -1, 1 );
11549 push2.y = rng( -1, 1 );
11550 point ipos2( mpos + push2 );
11551 tripoint pos( ipos2, get_levz() );
11552 if( ( push2.x == 0 && push2.y == 0 ) || ( ( ipos2.x == u.posx() ) && ( ipos2.y == u.posy() ) ) ) {
11553 continue;
11554 }
11555 if( !critter_at( pos ) && other.can_move_to( pos ) ) {
11556 other.setpos( tripoint( ipos2, get_levz() ) );
11557 other.moves -= 50;
11558 std::string msg;
11559 if( one_in( creature_throw_resist ) ) {
11560 other.add_effect( effect_downed, 2_turns );
11561 msg = _( "The %1$s pushed the %2$s hard." );
11562 } else {
11563 msg = _( "The %1$s pushed the %2$s." );
11564 }
11565 add_msg( m_neutral, msg, critter.name(), other.name() );
11566 return;
11567 }
11568 }
11569 return;
11570 }
11571 }
11572}
void setx(int x)
Definition: character.h:790
void sety(int y)
Definition: character.h:793
bool is_throw_immune() const
Returns true if the player is immune to throws.
float get_dodge() const override
Definition: melee.cpp:811
int monstairz
Definition: game.h:1032
tripoint_range< tripoint > points_on_zlevel() const
Yields a range of all points that are contained in the map and have the z-level of this map (abs_sub)...
Definition: map.cpp:8580
bool can_move_to(const tripoint &p) const
Checks whether we can move to/through p.
Definition: monmove.cpp:256
int posy() const override
Definition: monster.h:500
void melee_attack(Creature &target)
Definition: monster.cpp:1370
int staircount
Definition: monster.h:511
void spawn(const tripoint &p)
Definition: monster.cpp:481
int posx() const override
Definition: monster.h:497
bool thrown_by_judo(monster *z)
Definition: monattack.cpp:4671
std::enable_if<!is_std_array< C >::value, constV & >::type random_entry_ref(const C &container)
Same as above, but with a statically allocated default value (using the default constructor).
Definition: rng.h:149

References _, Creature::add_effect(), add_msg(), monster::can_move_to(), coming_to_stairs, critter_at(), debugmsg, effect_downed, g, Character::get_dodge(), get_levz(), map::has_flag(), Character::has_trait(), map::has_zlevels(), is_empty(), Character::is_throw_immune(), m, m_neutral, m_warning, MAPSIZE_X, MAPSIZE_Y, monster::melee_attack(), monstairz, sounds::movement, Creature::moves, monster::name(), one_in(), other, place_critter_at(), point_north_west, map::points_on_zlevel(), Character::pos(), Character::posx(), monster::posx(), Character::posy(), monster::posy(), Character::posz(), monexamine::push(), random_entry_ref(), rl_dist(), rng(), Character::sees(), Character::setx(), Character::sety(), sounds::sound(), monster::spawn(), monster::staircount, string_format(), map::tername(), mattack::thrown_by_judo(), trait_LEG_TENT_BRACE, u, point::x, and point::y.

Referenced by do_turn(), and vertical_move().

◆ update_zombie_pos()

bool game::update_zombie_pos ( const monster critter,
const tripoint pos 
)

Redirects to the creature_tracker update_pos() function.

Definition at line 5041 of file game.cpp.

5042{
5043 return critter_tracker->update_pos( critter, pos );
5044}

References critter_tracker.

◆ use_computer()

void game::use_computer ( const tripoint p)

Checks to see if a player can use a computer (not illiterate, etc.) and uses if able.

Definition at line 4824 of file game.cpp.

4825{
4826 if( u.has_trait( trait_id( "ILLITERATE" ) ) ) {
4827 add_msg( m_info, _( "You can not read a computer screen!" ) );
4828 return;
4829 }
4830 if( u.is_blind() ) {
4831 // we don't have screen readers in game
4832 add_msg( m_info, _( "You can not see a computer screen!" ) );
4833 return;
4834 }
4835 if( u.has_trait( trait_id( "HYPEROPIC" ) ) && !u.worn_with_flag( "FIX_FARSIGHT" ) &&
4836 !u.has_effect( effect_contacts ) && !u.has_bionic( bionic_id( "bio_eye_optic" ) ) ) {
4837 add_msg( m_info, _( "You'll need to put on reading glasses before you can see the screen." ) );
4838 return;
4839 }
4840
4841 computer *used = m.computer_at( p );
4842
4843 if( used == nullptr ) {
4844 if( m.has_flag( "CONSOLE", p ) ) { //Console without map data
4845 add_msg( m_bad, _( "The console doesn't display anything coherent." ) );
4846 } else {
4847 debugmsg( "Tried to use computer at %s - none there", p.to_string() );
4848 }
4849 return;
4850 }
4851
4852 computer_session( *used ).use();
4853}
void use()
Handles player use of a computer.
computer * computer_at(const tripoint &p)
Definition: map.cpp:5532
static const efftype_id effect_contacts("contacts")

References _, add_msg(), map::computer_at(), debugmsg, effect_contacts, Character::has_bionic(), Creature::has_effect(), map::has_flag(), Character::has_trait(), Character::is_blind(), m, m_bad, m_info, tripoint::to_string(), u, computer_session::use(), and Character::worn_with_flag().

Referenced by examine().

◆ validate_camps()

void game::validate_camps ( )

validate camps to ensure they are on the overmap list

Definition at line 2038 of file game.cpp.

2039{
2040 basecamp camp = m.hoist_submap_camp( u.pos() );
2041 if( camp.is_valid() ) {
2042 overmap_buffer.add_camp( camp );
2044 } else if( camp.camp_omt_pos() != tripoint_abs_omt() ) {
2045 std::string camp_name = _( "Faction Camp" );
2046 camp.set_name( camp_name );
2047 overmap_buffer.add_camp( camp );
2049 }
2050}
bool is_valid() const
Definition: basecamp.h:125
void set_name(const std::string &new_name)
Definition: basecamp.cpp:575
tripoint_abs_omt camp_omt_pos() const
Definition: basecamp.h:134
basecamp hoist_submap_camp(const tripoint &p)
Definition: map.cpp:5563
void remove_submap_camp(const tripoint &)
Definition: map.cpp:5558
void add_camp(const basecamp &camp)
Add Basecamp to overmapbuffer.

References _, overmapbuffer::add_camp(), basecamp::camp_omt_pos(), map::hoist_submap_camp(), basecamp::is_valid(), m, overmap_buffer, Character::pos(), map::remove_submap_camp(), basecamp::set_name(), and u.

Referenced by load().

◆ validate_linked_vehicles()

void game::validate_linked_vehicles ( )

validate towed vehicles so they get linked up again after a load

Definition at line 1980 of file game.cpp.

1981{
1982 for( auto &veh : m.get_vehicles() ) {
1983 vehicle *v = veh.v;
1986 if( other_v ) {
1987 // the other vehicle is towing us.
1988 v->tow_data.set_towing( other_v, v );
1990 }
1991 }
1992 }
1993}
tripoint other_towing_point
Definition: vehicle.h:167
bool set_towing(vehicle *tower_veh, vehicle *towed_veh)
Definition: vehicle.cpp:6117
towing_data tow_data
Definition: vehicle.h:1944

References map::get_vehicles(), m, towing_data::other_towing_point, towing_data::set_towing(), vehicle::tow_data, tripoint_zero, map::veh_at(), and veh_pointer_or_null().

Referenced by load().

◆ validate_mounted_npcs()

void game::validate_mounted_npcs ( )

Definition at line 1995 of file game.cpp.

1996{
1997 for( monster &m : all_monsters() ) {
1998 if( m.has_effect( effect_ridden ) && m.mounted_player_id.is_valid() ) {
1999 player *mounted_pl = g->critter_by_id<player>( m.mounted_player_id );
2000 if( !mounted_pl ) {
2001 // Target no longer valid.
2002 m.mounted_player_id = character_id();
2003 m.remove_effect( effect_ridden );
2004 continue;
2005 }
2006 mounted_pl->mounted_creature = shared_from( m );
2007 mounted_pl->setpos( m.pos() );
2008 mounted_pl->add_effect( effect_riding, 1_turns, num_bp );
2009 m.mounted_player = mounted_pl;
2010 }
2011 }
2012}

References Creature::add_effect(), all_monsters(), character_id, effect_ridden, effect_riding, g, m, Character::mounted_creature, num_bp, Character::setpos(), and shared_from().

Referenced by load(), and vertical_shift().

◆ validate_npc_followers()

void game::validate_npc_followers ( )

validate list of followers to account for overmap buffers

Definition at line 2014 of file game.cpp.

2015{
2016 // Make sure visible followers are in the list.
2017 const std::vector<npc *> visible_followers = get_npcs_if( [&]( const npc & guy ) {
2018 return guy.is_player_ally();
2019 } );
2020 for( npc *guy : visible_followers ) {
2021 update_faction_api( guy );
2022 add_npc_follower( guy->getID() );
2023 }
2024 // Make sure overmapbuffered NPC followers are in the list.
2025 for( const auto &temp_guy : overmap_buffer.get_npcs_near_player( 300 ) ) {
2026 npc *guy = temp_guy.get();
2027 if( guy->is_player_ally() ) {
2028 update_faction_api( guy );
2029 add_npc_follower( guy->getID() );
2030 }
2031 }
2032 // Make sure that serialized player followers sync up with game list
2033 for( const auto &temp_id : u.follower_ids ) {
2034 add_npc_follower( temp_id );
2035 }
2036}
void add_npc_follower(const character_id &id)
Add follower id to set of followers.
Definition: game.cpp:1960
static void update_faction_api(npc *guy)
Definition: game.cpp:1972

References add_npc_follower(), player::follower_ids, get_npcs_if(), overmapbuffer::get_npcs_near_player(), Character::getID(), npc::is_player_ally(), overmap_buffer, u, and update_faction_api().

Referenced by load().

◆ vertical_move()

void game::vertical_move ( int  z,
bool  force,
bool  peeking = false 
)

Moves the player vertically.

If force == true then they are falling. If peeking == true, forbids some exotic movement options

Strength increases breath-holding capacity while diving Dexterity increases chance of moving past monsters on stairs Dodge increases chance of moving past monsters on stairs Strength increases chance of moving past monsters on stairs Melee increases chance of moving past monsters on stairs

Definition at line 10539 of file game.cpp.

10540{
10541 if( u.is_mounted() ) {
10542 auto mons = u.mounted_creature.get();
10543 if( mons->has_flag( MF_RIDEABLE_MECH ) ) {
10544 if( !mons->check_mech_powered() ) {
10545 add_msg( m_bad, _( "Your %s refuses to move as its batteries have been drained." ),
10546 mons->get_name() );
10547 return;
10548 }
10549 }
10550 }
10551
10552 // > and < are used for diving underwater.
10553 if( m.has_flag( "SWIMMABLE", u.pos() ) && m.has_flag( TFLAG_DEEP_WATER, u.pos() ) ) {
10554 if( movez == -1 ) {
10555 if( u.is_underwater() ) {
10556 add_msg( m_info, _( "You are already underwater!" ) );
10557 return;
10558 }
10559 if( u.worn_with_flag( "FLOTATION" ) ) {
10560 add_msg( m_info, _( "You can't dive while wearing a flotation device." ) );
10561 return;
10562 }
10563 u.set_underwater( true );
10564 ///\EFFECT_STR increases breath-holding capacity while diving
10565 u.oxygen = 30 + 2 * u.str_cur;
10566 add_msg( _( "You dive underwater!" ) );
10567 } else {
10568 if( u.swim_speed() < 500 || u.shoe_type_count( itype_swim_fins ) ) {
10569 u.set_underwater( false );
10570 add_msg( _( "You surface." ) );
10571 } else {
10572 add_msg( m_info, _( "You try to surface but can't!" ) );
10573 }
10574 }
10575 u.moves -= 100;
10576 return;
10577 }
10578
10579 // Force means we're going down, even if there's no staircase, etc.
10580 bool climbing = false;
10581 int move_cost = 100;
10582 tripoint stairs( u.posx(), u.posy(), u.posz() + movez );
10583 if( m.has_zlevels() && !force && movez == 1 && !m.has_flag( "GOES_UP", u.pos() ) ) {
10584 // Climbing
10585 if( m.has_floor_or_support( stairs ) ) {
10586 add_msg( m_info, _( "You can't climb here - there's a ceiling above your head." ) );
10587 return;
10588 }
10589
10590 std::vector<tripoint> pts;
10591 for( const auto &pt : m.points_in_radius( stairs, 1 ) ) {
10592 if( m.passable( pt ) &&
10593 m.has_floor_or_support( pt ) ) {
10594 pts.push_back( pt );
10595 }
10596 }
10597
10598 const int cost = map_funcs::climbing_cost( m, u.pos(), stairs );
10599
10600 if( cost == 0 ) {
10601 if( u.has_trait( trait_WEB_ROPE ) ) {
10602 if( pts.empty() ) {
10603 add_msg( m_info, _( "There is nothing above you that you can attach a web to." ) );
10604 } else if( can_use_mutation_warn( trait_WEB_ROPE, u ) ) {
10605 if( g->m.move_cost( u.pos() ) != 2 && g->m.move_cost( u.pos() ) != 3 ) {
10606 add_msg( m_info, _( "You can't spin a web rope there." ) );
10607 } else if( g->m.has_furn( u.pos() ) ) {
10608 add_msg( m_info, _( "There is already furniture at that location." ) );
10609 } else {
10610 if( query_yn( "Spin a rope and climb?" ) ) {
10611 add_msg( m_good, _( "You spin a rope of web." ) );
10612 g->m.furn_set( u.pos(), furn_str_id( "f_rope_up_web" ) );
10613 u.mod_moves( to_turns<int>( 2_seconds ) );
10615 vertical_move( movez, force, peeking );
10616 }
10617 }
10618 }
10619
10620 } else {
10621 add_msg( m_info, _( "You can't climb here - you need walls and/or furniture to brace against." ) );
10622
10623 }
10624 return;
10625
10626 }
10627
10628 if( cost <= 0 || pts.empty() ) {
10629 add_msg( m_info,
10630 _( "You can't climb here - there is no terrain above you that would support your weight." ) );
10631 return;
10632 } else {
10633 // TODO: Make it an extended action
10634 climbing = true;
10635 move_cost = cost;
10636
10638 if( !pnt ) {
10639 return;
10640 }
10641 stairs = *pnt;
10642 }
10643 }
10644
10645 if( !force && movez == -1 && !m.has_flag( "GOES_DOWN", u.pos() ) ) {
10646 add_msg( m_info, _( "You can't go down here!" ) );
10647 return;
10648 } else if( !climbing && !force && movez == 1 && !m.has_flag( "GOES_UP", u.pos() ) ) {
10649 add_msg( m_info, _( "You can't go up here!" ) );
10650 return;
10651 }
10652
10653 if( force ) {
10654 // Let go of a grabbed cart.
10655 u.grab( OBJECT_NONE );
10656 } else if( u.grab_point != tripoint_zero ) {
10657 add_msg( m_info, _( "You can't drag things up and down stairs." ) );
10658 return;
10659 }
10660
10661 // Because get_levz takes z-value from the map, it will change when vertical_shift (m.has_zlevels() == true)
10662 // is called or when the map is loaded on new z-level (== false).
10663 // This caches the z-level we start the movement on (current) and the level we're want to end.
10664 const int z_before = get_levz();
10665 const int z_after = get_levz() + movez;
10666 if( z_after < -OVERMAP_DEPTH || z_after > OVERMAP_HEIGHT ) {
10667 debugmsg( "Tried to move outside allowed range of z-levels" );
10668 return;
10669 }
10670
10671 if( !u.move_effects( false ) ) {
10672 return;
10673 }
10674
10675 // Check if there are monsters are using the stairs.
10676 bool slippedpast = false;
10677 if( !m.has_zlevels() && !coming_to_stairs.empty() && !force ) {
10678 // TODO: Allow travel if zombie couldn't reach stairs, but spawn him when we go up.
10679 add_msg( m_warning, _( "You try to use the stairs. Suddenly you are blocked by a %s!" ),
10680 coming_to_stairs[0].name() );
10681 // Roll.
10682 ///\EFFECT_DEX increases chance of moving past monsters on stairs
10683
10684 ///\EFFECT_DODGE increases chance of moving past monsters on stairs
10685 int dexroll = dice( 6, u.dex_cur + u.get_skill_level( skill_dodge ) * 2 );
10686 ///\EFFECT_STR increases chance of moving past monsters on stairs
10687
10688 ///\EFFECT_MELEE increases chance of moving past monsters on stairs
10689 int strroll = dice( 3, u.str_cur + u.get_skill_level( skill_melee ) * 1.5 );
10690 if( coming_to_stairs.size() > 4 ) {
10691 add_msg( _( "The are a lot of them on the %s!" ), m.tername( u.pos() ) );
10692 dexroll /= 4;
10693 strroll /= 2;
10694 } else if( coming_to_stairs.size() > 1 ) {
10695 add_msg( m_warning, _( "There's something else behind it!" ) );
10696 dexroll /= 2;
10697 }
10698
10699 if( dexroll < 14 || strroll < 12 ) {
10701 u.moves -= 100;
10702 return;
10703 }
10704
10705 add_msg( _( "You manage to slip past!" ) );
10706 slippedpast = true;
10707 u.moves -= 100;
10708 }
10709
10710 // Shift the map up or down
10711
10712 std::unique_ptr<map> tmp_map_ptr;
10713 if( !m.has_zlevels() ) {
10714 tmp_map_ptr = std::make_unique<map>();
10715 }
10716
10717 map &maybetmp = m.has_zlevels() ? m : *( tmp_map_ptr.get() );
10718 if( m.has_zlevels() ) {
10719 // We no longer need to shift the map here! What joy
10720 } else {
10721 maybetmp.load( tripoint( get_levx(), get_levy(), z_after ), false );
10722 }
10723
10724 // Find the corresponding staircase
10725 bool rope_ladder = false;
10726 // TODO: Remove the stairfinding, make the mapgen gen aligned maps
10727 if( !force && !climbing ) {
10728 const cata::optional<tripoint> pnt = find_or_make_stairs( maybetmp, z_after, rope_ladder, peeking );
10729 if( !pnt ) {
10730 return;
10731 }
10732 stairs = *pnt;
10733 }
10734
10735 if( !force ) {
10736 monstairz = z_before;
10737 }
10738 // Save all monsters that can reach the stairs, remove them from the tracker,
10739 // then despawn the remaining monsters. Because it's a vertical shift, all
10740 // monsters are out of the bounds of the map and will despawn.
10741 shared_ptr_fast<monster> stored_mount;
10742 if( u.is_mounted() && !m.has_zlevels() ) {
10743 // Store a *copy* of the mount, so we can remove the original monster instance
10744 // from the tracker before the map shifts.
10745 // Map shifting would otherwise just despawn the mount and would later respawn it.
10746 stored_mount = make_shared_fast<monster>( *u.mounted_creature );
10748 }
10749 if( !m.has_zlevels() ) {
10750 const tripoint to = u.pos();
10751 for( monster &critter : all_monsters() ) {
10752 // if its a ladder instead of stairs - most zombies can't climb that.
10753 // unless that have a special flag to allow them to do so.
10754 if( ( m.has_flag( "DIFFICULT_Z", u.pos() ) && !critter.climbs() ) ||
10755 critter.has_effect( effect_ridden ) ||
10756 critter.has_effect( effect_tied ) ) {
10757 continue;
10758 }
10759 int turns = critter.turns_to_reach( to.xy() );
10760 if( turns < 10 && coming_to_stairs.size() < 8 && critter.will_reach( to.xy() )
10761 && !slippedpast ) {
10762 critter.staircount = 10 + turns;
10763 critter.on_unload();
10764 coming_to_stairs.push_back( critter );
10765 remove_zombie( critter );
10766 }
10767 }
10768 auto mons = critter_tracker->find( g->u.pos() );
10769 if( mons != nullptr ) {
10770 critter_tracker->remove( *mons );
10771 }
10772 shift_monsters( tripoint( 0, 0, movez ) );
10773 }
10774
10775 std::vector<shared_ptr_fast<npc>> npcs_to_bring;
10776 std::vector<monster *> monsters_following;
10777 if( !m.has_zlevels() && std::abs( movez ) == 1 ) {
10778 std::copy_if( active_npc.begin(), active_npc.end(), back_inserter( npcs_to_bring ),
10779 [this]( const shared_ptr_fast<npc> &np ) {
10780 return np->is_walking_with() && !np->is_mounted() && !np->in_sleep_state() &&
10781 rl_dist( np->pos(), u.pos() ) < 2;
10782 } );
10783 }
10784
10785 if( m.has_zlevels() && std::abs( movez ) == 1 ) {
10786 bool ladder = m.has_flag( "DIFFICULT_Z", u.pos() );
10787 for( monster &critter : all_monsters() ) {
10788 if( ladder && !critter.climbs() ) {
10789 continue;
10790 }
10791 if( critter.attack_target() == &g->u || ( !critter.has_effect( effect_ridden ) &&
10792 critter.has_effect( effect_pet ) && critter.friendly == -1 &&
10793 !critter.has_effect( effect_tied ) ) ) {
10794 monsters_following.push_back( &critter );
10795 }
10796 }
10797 }
10798
10799 if( u.is_mounted() ) {
10800 monster *crit = u.mounted_creature.get();
10801 if( crit->has_flag( MF_RIDEABLE_MECH ) ) {
10802 crit->use_mech_power( -1 );
10803 if( u.movement_mode_is( CMM_WALK ) ) {
10804 crit->use_mech_power( -2 );
10805 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
10806 crit->use_mech_power( -1 );
10807 } else if( u.movement_mode_is( CMM_RUN ) ) {
10808 crit->use_mech_power( -3 );
10809 }
10810 }
10811 } else {
10812 u.moves -= move_cost;
10813 }
10814 for( const auto &np : npcs_to_bring ) {
10815 if( np->in_vehicle ) {
10816 m.unboard_vehicle( np->pos() );
10817 }
10818 }
10819 const tripoint old_pos = g->u.pos();
10820 point submap_shift;
10821 vertical_shift( z_after );
10822 if( !force ) {
10823 submap_shift = update_map( stairs.x, stairs.y );
10824 }
10825
10826 // if an NPC or monster is on the stiars when player ascends/descends
10827 // they may end up merged on th esame tile, do some displacement to resolve that.
10828 // if, in the weird case of it not being possible to displace;
10829 // ( how did the player even manage to approach the stairs, if so? )
10830 // then nothing terrible happens, its just weird.
10831 if( critter_at<npc>( u.pos(), true ) || critter_at<monster>( u.pos(), true ) ) {
10832 std::string crit_name;
10833 bool player_displace = false;
10835 if( displace.has_value() ) {
10836 npc *guy = g->critter_at<npc>( u.pos(), true );
10837 if( guy ) {
10838 crit_name = guy->get_name();
10839 tripoint old_pos = guy->pos();
10840 if( !guy->is_enemy() ) {
10841 guy->move_away_from( u.pos(), true );
10842 if( old_pos != guy->pos() ) {
10843 add_msg( _( "%s moves out of the way for you." ), guy->get_name() );
10844 }
10845 } else {
10846 player_displace = true;
10847 }
10848 }
10849 monster *mon = g->critter_at<monster>( u.pos(), true );
10850 // if the monster is ridden by the player or an NPC:
10851 // Dont displace them. If they are mounted by a friendly NPC,
10852 // then the NPC will already have been displaced just above.
10853 // if they are ridden by the player, we want them to coexist on same tile
10854 if( mon && !mon->mounted_player ) {
10855 crit_name = mon->get_name();
10856 if( mon->friendly == -1 ) {
10857 mon->setpos( *displace );
10858 add_msg( _( "Your %s moves out of the way for you." ), mon->get_name() );
10859 } else {
10860 player_displace = true;
10861 }
10862 }
10863 if( player_displace ) {
10864 u.setpos( *displace );
10865 u.moves -= 20;
10866 add_msg( _( "You push past %s blocking the way." ), crit_name );
10867 }
10868 } else {
10869 debugmsg( "Failed to find a spot to displace into." );
10870 }
10871 }
10872
10873 // Now that we know the player's destination position, we can move their mount as well
10874 if( u.is_mounted() ) {
10875 if( stored_mount ) {
10876 assert( !m.has_zlevels() );
10877 stored_mount->spawn( g->u.pos() );
10878 if( critter_tracker->add( stored_mount ) ) {
10879 u.mounted_creature = stored_mount;
10880 }
10881 } else {
10882 u.mounted_creature->setpos( g->u.pos() );
10883 }
10884 }
10885
10886 if( !npcs_to_bring.empty() ) {
10887 // Would look nicer randomly scrambled
10888 std::vector<tripoint> candidates = closest_points_first( u.pos(), 1 );
10889 candidates.erase( std::remove_if( candidates.begin(), candidates.end(),
10890 [this]( const tripoint & c ) {
10891 return !is_empty( c );
10892 } ), candidates.end() );
10893
10894 for( const auto &np : npcs_to_bring ) {
10895 const auto found = std::find_if( candidates.begin(), candidates.end(),
10896 [this, np]( const tripoint & c ) {
10897 return !np->is_dangerous_fields( m.field_at( c ) ) && m.tr_at( c ).is_benign();
10898 } );
10899 if( found != candidates.end() ) {
10900 // TODO: De-uglify
10901 np->setpos( *found );
10902 np->place_on_map();
10903 np->setpos( *found );
10904 candidates.erase( found );
10905 }
10906
10907 if( candidates.empty() ) {
10908 break;
10909 }
10910 }
10911
10912 reload_npcs();
10913 }
10914
10915 // This ugly check is here because of stair teleport bullshit
10916 // TODO: Remove stair teleport bullshit
10917 if( rl_dist( g->u.pos(), old_pos ) <= 1 ) {
10918 for( monster *m : monsters_following ) {
10919 m->set_dest( g->u.pos() );
10920 }
10921 }
10922
10923 if( rope_ladder ) {
10924 m.ter_set( u.pos(), t_rope_up );
10925 }
10926
10927 if( m.ter( stairs ) == t_manhole_cover ) {
10928 m.spawn_item( stairs + point( rng( -1, 1 ), rng( -1, 1 ) ), itype_manhole_cover );
10929 m.ter_set( stairs, t_manhole );
10930 }
10931
10932 // Wouldn't work and may do strange things
10933 if( u.is_hauling() && !m.has_zlevels() ) {
10934 add_msg( _( "You cannot haul items here." ) );
10935 u.stop_hauling();
10936 }
10937
10938 if( u.is_hauling() ) {
10939 const tripoint adjusted_pos = old_pos - sm_to_ms_copy( submap_shift );
10940 start_hauling( adjusted_pos );
10941 }
10942
10943 m.invalidate_map_cache( g->get_levz() );
10944 // Upon force movement, traps can not be avoided.
10945 m.creature_on_trap( u, !force );
10946
10948}
static int move_cost(const item &it, const tripoint &src, const tripoint &dest)
@ CMM_WALK
Definition: character.h:101
@ CMM_CROUCH
Definition: character.h:103
bool move_effects(bool attacking) override
Processes effects which may prevent the Character from moving (bear traps, crushed,...
Definition: character.cpp:1538
int swim_speed() const
Returns the player's speed for swimming across water tiles.
Definition: character.cpp:882
int oxygen
Definition: character.h:1538
void mutation_spend_resources(const trait_id &mut)
Removes the appropriate costs (NOTE: will reapply mods & recalc sightlines in case of newly activated...
Definition: mutation.cpp:1723
int shoe_type_count(const itype_id &it) const
Returns 1 if the player is wearing an item of that count on one foot, 2 if on both,...
Definition: character.cpp:8961
std::string get_name() const override
Definition: character.cpp:6110
void start_hauling(const tripoint &pos)
Definition: game.cpp:10950
cata::optional< tripoint > find_or_make_stairs(map &mp, int z_after, bool &rope_ladder, bool peeking)
Returns the other end of the stairs (if any).
Definition: game.cpp:10985
bool use_mech_power(int amt)
Definition: monster.cpp:2372
Character * mounted_player
Definition: monster.h:460
void set_underwater(bool)
Definition: player.cpp:517
static const efftype_id effect_tied("tied")
static const itype_id itype_manhole_cover("manhole_cover")
static const skill_id skill_melee("melee")
static cata::optional< tripoint > point_selection_menu(const std::vector< tripoint > &pts)
Definition: game.cpp:10489
static const itype_id itype_swim_fins("swim_fins")
static const trait_id trait_WEB_ROPE("WEB_ROPE")
ter_id t_rope_up
Definition: mapdata.cpp:719
ter_id t_manhole
Definition: mapdata.cpp:718
bool can_use_mutation_warn(const trait_id &mut, const Character &character)
Calls can_use_mutation and if it fails, print a standard message.
Definition: mutation.cpp:1712
void avatar_moves(const avatar &u, const map &m, const tripoint &p)
Definition: game.cpp:12608
int ladder(player *, item *, bool, const tripoint &)
Definition: iuse.cpp:9345
int climbing_cost(const map &m, const tripoint &from, const tripoint &to)
Checks both the neighborhoods of from and to for climbable surfaces, returns move cost of climbing fr...
point displace(type dir, int dist=1)
Returns point(0, 0) displaced in specified direction by a specified distance.
Definition: overmap.cpp:4169

References _, active_npc, add_msg(), all_monsters(), cata_event_dispatch::avatar_moves(), c, can_use_mutation_warn(), map_funcs::climbing_cost(), closest_points_first(), CMM_CROUCH, CMM_RUN, CMM_WALK, coming_to_stairs, map::creature_on_trap(), critter_tracker, debugmsg, Character::dex_cur, dice(), om_direction::displace(), effect_pet, effect_ridden, effect_tied, find_empty_spot_nearby(), find_or_make_stairs(), monster::friendly, g, get_levx(), get_levy(), get_levz(), Character::get_name(), monster::get_name(), Character::get_skill_level(), avatar::grab(), player::grab_point, map::has_flag(), monster::has_flag(), map::has_floor_or_support(), Character::has_trait(), map::has_zlevels(), map::invalidate_map_cache(), npc::is_enemy(), Character::is_hauling(), Character::is_mounted(), Creature::is_underwater(), itype_manhole_cover, itype_swim_fins, iuse::ladder(), map::load(), m, m_bad, m_good, m_info, m_warning, MF_RIDEABLE_MECH, Creature::mod_moves(), monstairz, Character::mounted_creature, monster::mounted_player, npc::move_away_from(), move_cost(), Character::move_effects(), Character::movement_mode_is(), Creature::moves, Character::mutation_spend_resources(), om_direction::name(), OBJECT_NONE, OVERMAP_HEIGHT, Character::oxygen, map::passable(), point_selection_menu(), map::points_in_radius(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), query_yn(), reload_npcs(), remove_zombie(), rl_dist(), rng(), player::set_underwater(), Character::setpos(), monster::setpos(), shift_monsters(), Character::shoe_type_count(), skill_dodge, skill_melee, sm_to_ms_copy(), map::spawn_item(), start_hauling(), Character::stop_hauling(), Character::str_cur, Character::swim_speed(), t_manhole, t_manhole_cover, t_rope_up, map::ter(), map::ter_set(), map::tername(), TFLAG_DEEP_WATER, trait_WEB_ROPE, tripoint_zero, u, map::unboard_vehicle(), update_map(), update_stair_monsters(), monster::use_mech_power(), vertical_move(), vertical_shift(), Character::worn_with_flag(), tripoint::x, tripoint::xy(), and tripoint::y.

Referenced by handle_action(), peek(), and vertical_move().

◆ vertical_notes()

void game::vertical_notes ( int  z_before,
int  z_after 
)

Add goes up/down auto_notes (if turned on)

Definition at line 11172 of file game.cpp.

11173{
11174 if( z_before == z_after || !get_option<bool>( "AUTO_NOTES" ) ||
11175 !get_option<bool>( "AUTO_NOTES_STAIRS" ) ) {
11176 return;
11177 }
11178
11179 if( !m.inbounds_z( z_before ) || !m.inbounds_z( z_after ) ) {
11180 debugmsg( "game::vertical_notes invalid arguments: z_before == %d, z_after == %d",
11181 z_before, z_after );
11182 return;
11183 }
11184 // Figure out where we know there are up/down connectors
11185 // Fill in all the tiles we know about (e.g. subway stations)
11186 static const int REVEAL_RADIUS = 40;
11187 for( const tripoint_abs_omt &p : points_in_radius( u.global_omt_location(), REVEAL_RADIUS ) ) {
11188 const tripoint_abs_omt cursp_before( p.xy(), z_before );
11189 const tripoint_abs_omt cursp_after( p.xy(), z_after );
11190
11191 if( !overmap_buffer.seen( cursp_before ) ) {
11192 continue;
11193 }
11194 if( overmap_buffer.has_note( cursp_after ) ) {
11195 // Already has a note -> never add an AUTO-note
11196 continue;
11197 }
11198 const oter_id &ter = overmap_buffer.ter( cursp_before );
11199 const oter_id &ter2 = overmap_buffer.ter( cursp_after );
11200 if( z_after > z_before && ter->has_flag( known_up ) &&
11201 !ter2->has_flag( known_down ) ) {
11202 overmap_buffer.set_seen( cursp_after, true );
11203 overmap_buffer.add_note( cursp_after, string_format( ">:W;%s", _( "AUTO: goes down" ) ) );
11204 } else if( z_after < z_before && ter->has_flag( known_down ) &&
11205 !ter2->has_flag( known_up ) ) {
11206 overmap_buffer.set_seen( cursp_after, true );
11207 overmap_buffer.add_note( cursp_after, string_format( "<:W;%s", _( "AUTO: goes up" ) ) );
11208 }
11209 }
11210}
bool inbounds_z(const int z) const
Definition: map.h:1665
void add_note(const tripoint_abs_omt &, const std::string &message)
@ known_up
Definition: omdata.h:87
@ known_down
Definition: omdata.h:86
bool has_flag(oter_flags flag) const
Definition: omdata.h:258

References _, overmapbuffer::add_note(), debugmsg, Character::global_omt_location(), oter_t::has_flag(), overmapbuffer::has_note(), map::inbounds_z(), known_down, known_up, m, overmap_buffer, points_in_radius(), overmapbuffer::seen(), overmapbuffer::set_seen(), string_format(), overmapbuffer::ter(), and u.

Referenced by vertical_shift().

◆ vertical_shift()

void game::vertical_shift ( int  z_after)

Actual z-level movement part of vertical_move.

Doesn't include stair finding, traps etc.

Definition at line 11135 of file game.cpp.

11136{
11137 if( z_after < -OVERMAP_DEPTH || z_after > OVERMAP_HEIGHT ) {
11138 debugmsg( "Tried to get z-level %d outside allowed range of %d-%d",
11139 z_after, -OVERMAP_DEPTH, OVERMAP_HEIGHT );
11140 return;
11141 }
11142
11143 // TODO: Implement dragging stuff up/down
11144 u.grab( OBJECT_NONE );
11145
11146 scent.reset();
11147
11148 u.setz( z_after );
11149 const int z_before = get_levz();
11150 if( !m.has_zlevels() ) {
11152 m.access_cache( z_before ).vehicle_list.clear();
11153 m.access_cache( z_before ).zone_vehicles.clear();
11154 m.access_cache( z_before ).map_memory_seen_cache.reset();
11155 m.set_transparency_cache_dirty( z_before );
11156 m.set_outside_cache_dirty( z_before );
11157 m.load( tripoint( get_levx(), get_levy(), z_after ), true );
11158 shift_monsters( tripoint( 0, 0, z_after - z_before ) );
11159 reload_npcs();
11160 } else {
11161 // Shift the map itself
11162 m.vertical_shift( z_after );
11163 }
11164
11165 m.spawn_monsters( true );
11166 // this may be required after a vertical shift if z-levels are not enabled
11167 // the critter is unloaded/loaded, and it needs to reconstruct its rider data after being reloaded.
11169 vertical_notes( z_before, z_after );
11170}
void setz(int z)
Definition: character.h:796
void vertical_notes(int z_before, int z_after)
Add goes up/down auto_notes (if turned on)
Definition: game.cpp:11172
void set_transparency_cache_dirty(const int zlev)
Sets a dirty flag on the a given cache.
Definition: map.h:406
void set_outside_cache_dirty(const int zlev)
Definition: map.h:443
void vertical_shift(int newz)
Moves the map vertically to (not by!) newz.
Definition: map.cpp:6864
std::set< vehicle * > zone_vehicles
Definition: map.h:359
std::set< vehicle * > vehicle_list
Definition: map.h:358

References map::access_cache(), map::clear_vehicle_cache(), debugmsg, get_levx(), get_levy(), get_levz(), avatar::grab(), map::has_zlevels(), map::load(), m, level_cache::map_memory_seen_cache, OBJECT_NONE, OVERMAP_DEPTH, OVERMAP_HEIGHT, reload_npcs(), scent_map::reset(), scent, map::set_outside_cache_dirty(), map::set_transparency_cache_dirty(), Character::setz(), shift_monsters(), map::spawn_monsters(), u, validate_mounted_npcs(), level_cache::vehicle_list, vertical_notes(), map::vertical_shift(), and level_cache::zone_vehicles.

Referenced by place_player(), and vertical_move().

◆ walk_move()

bool game::walk_move ( const tripoint dest,
bool  via_ramp = false 
)

TODO: This should really use the mounted creatures stamina, if mounted. Monsters don't currently have stamina however. For the time being just don't burn players stamina when mounted.

Dexterity decreases chance of tentacles getting stuck to the ground Intelligence decreases chance of tentacles getting stuck to the ground

Definition at line 9330 of file game.cpp.

9331{
9332 if( m.has_flag_ter( TFLAG_SMALL_PASSAGE, dest_loc ) ) {
9333 if( u.get_size() > MS_MEDIUM ) {
9334 add_msg( m_warning, _( "You can't fit there." ) );
9335 return false; // character too large to fit through a tight passage
9336 }
9337 if( u.is_mounted() ) {
9338 monster *mount = u.mounted_creature.get();
9339 if( mount->get_size() > MS_MEDIUM ) {
9340 add_msg( m_warning, _( "Your mount can't fit there." ) );
9341 return false; // char's mount is too large for tight passages
9342 }
9343 }
9344 }
9345
9346 if( u.is_mounted() ) {
9347 auto mons = u.mounted_creature.get();
9348 if( mons->has_flag( MF_RIDEABLE_MECH ) ) {
9349 if( !mons->check_mech_powered() ) {
9350 add_msg( m_bad, _( "Your %s refuses to move as its batteries have been drained." ),
9351 mons->get_name() );
9352 return false;
9353 }
9354 }
9355 if( !mons->move_effects( false ) ) {
9356 add_msg( m_bad, _( "You cannot move as your %s isn't able to move." ), mons->get_name() );
9357 return false;
9358 }
9359 }
9360 const optional_vpart_position vp_here = m.veh_at( u.pos() );
9361 const optional_vpart_position vp_there = m.veh_at( dest_loc );
9362
9363 bool pushing = false; // moving -into- grabbed tile; skip check for move_cost > 0
9364 bool pulling = false; // moving -away- from grabbed tile; check for move_cost > 0
9365 bool shifting_furniture = false; // moving furniture and staying still; skip check for move_cost > 0
9366
9367 const tripoint furn_pos = u.pos() + u.grab_point;
9368 const tripoint furn_dest = dest_loc + u.grab_point;
9369
9370 bool grabbed = u.get_grab_type() != OBJECT_NONE;
9371 if( grabbed ) {
9372 const tripoint dp = dest_loc - u.pos();
9373 pushing = dp == u.grab_point;
9374 pulling = dp == -u.grab_point;
9375 }
9376 if( grabbed && dest_loc.z != u.posz() ) {
9377 add_msg( m_warning, _( "You let go of the grabbed object." ) );
9378 grabbed = false;
9379 u.grab( OBJECT_NONE );
9380 }
9381
9382 // Now make sure we're actually holding something
9383 const vehicle *grabbed_vehicle = nullptr;
9384 if( grabbed && u.get_grab_type() == OBJECT_FURNITURE ) {
9385 // We only care about shifting, because it's the only one that can change our destination
9386 if( m.has_furn( u.pos() + u.grab_point ) ) {
9387 shifting_furniture = !pushing && !pulling;
9388 } else {
9389 // We were grabbing a furniture that isn't there
9390 grabbed = false;
9391 }
9392 } else if( grabbed && u.get_grab_type() == OBJECT_VEHICLE ) {
9393 grabbed_vehicle = veh_pointer_or_null( m.veh_at( u.pos() + u.grab_point ) );
9394 if( grabbed_vehicle == nullptr ) {
9395 // We were grabbing a vehicle that isn't there anymore
9396 grabbed = false;
9397 }
9398 } else if( grabbed ) {
9399 // We were grabbing something WEIRD, let's pretend we weren't
9400 grabbed = false;
9401 }
9402 if( u.grab_point != tripoint_zero && !grabbed ) {
9403 add_msg( m_warning, _( "Can't find grabbed object." ) );
9404 u.grab( OBJECT_NONE );
9405 }
9406
9407 if( m.impassable( dest_loc ) && !pushing && !shifting_furniture ) {
9408 if( vp_there && u.mounted_creature && u.mounted_creature->has_flag( MF_RIDEABLE_MECH ) &&
9409 vp_there->vehicle().handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
9410 tripoint diff = dest_loc - u.pos();
9411 if( diff.x < 0 ) {
9412 diff.x -= 2;
9413 } else if( diff.x > 0 ) {
9414 diff.x += 2;
9415 }
9416 if( diff.y < 0 ) {
9417 diff.y -= 2;
9418 } else if( diff.y > 0 ) {
9419 diff.y += 2;
9420 }
9421 u.mounted_creature->shove_vehicle( dest_loc + diff.xy(),
9422 dest_loc );
9423 }
9424 return false;
9425 }
9426 if( vp_there && !vp_there->vehicle().handle_potential_theft( dynamic_cast<player &>( u ) ) ) {
9427 return false;
9428 }
9429 if( u.is_mounted() && !pushing && vp_there ) {
9430 add_msg( m_warning, _( "You cannot board a vehicle whilst riding." ) );
9431 return false;
9432 }
9433 u.set_underwater( false );
9434
9435 if( !shifting_furniture && !pushing && is_dangerous_tile( dest_loc ) ) {
9436 std::vector<std::string> harmful_stuff = get_dangerous_tile( dest_loc );
9437 if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "ALWAYS" &&
9438 !prompt_dangerous_tile( dest_loc ) ) {
9439 return true;
9440 } else if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "RUNNING" &&
9441 ( !u.movement_mode_is( CMM_RUN ) || !prompt_dangerous_tile( dest_loc ) ) ) {
9443 _( "Stepping into that %1$s looks risky. Run into it if you wish to enter anyway." ),
9444 enumerate_as_string( harmful_stuff ) );
9445 return true;
9446 } else if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "CROUCHING" &&
9447 ( !u.movement_mode_is( CMM_CROUCH ) || !prompt_dangerous_tile( dest_loc ) ) ) {
9449 _( "Stepping into that %1$s looks risky. Crouch and move into it if you wish to enter anyway." ),
9450 enumerate_as_string( harmful_stuff ) );
9451 return true;
9452 } else if( get_option<std::string>( "DANGEROUS_TERRAIN_WARNING_PROMPT" ) == "NEVER" &&
9453 !u.movement_mode_is( CMM_RUN ) ) {
9455 _( "Stepping into that %1$s looks risky. Run into it if you wish to enter anyway." ),
9456 enumerate_as_string( harmful_stuff ) );
9457 return true;
9458 }
9459 }
9460 // Used to decide whether to print a 'moving is slow message
9461 const int mcost_from = m.move_cost( u.pos() ); //calculate this _before_ calling grabbed_move
9462
9463 int modifier = 0;
9464 if( grabbed && u.get_grab_type() == OBJECT_FURNITURE && u.pos() + u.grab_point == dest_loc ) {
9465 modifier = -m.furn( dest_loc ).obj().movecost;
9466 }
9467
9468 int multiplier = 1;
9469 if( u.is_on_ground() ) {
9470 multiplier *= 3;
9471 }
9472
9473 const int mcost = m.combined_movecost( u.pos(), dest_loc, grabbed_vehicle, modifier,
9474 via_ramp ) * multiplier;
9475 if( grabbed_move( dest_loc - u.pos() ) ) {
9476 return true;
9477 } else if( mcost == 0 ) {
9478 return false;
9479 }
9480 bool diag = trigdist && u.posx() != dest_loc.x && u.posy() != dest_loc.y;
9481 const int previous_moves = u.moves;
9482 if( u.is_mounted() ) {
9483 auto crit = u.mounted_creature.get();
9484 if( !crit->has_flag( MF_RIDEABLE_MECH ) &&
9485 ( m.has_flag_ter_or_furn( "MOUNTABLE", dest_loc ) ||
9486 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR", dest_loc ) ||
9487 m.has_flag_ter_or_furn( "OPENCLOSE_INSIDE", dest_loc ) ||
9488 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR_DAMAGED", dest_loc ) ||
9489 m.has_flag_ter_or_furn( "BARRICADABLE_DOOR_REINFORCED", dest_loc ) ) ) {
9490 add_msg( m_warning, _( "You cannot pass obstacles whilst mounted." ) );
9491 return false;
9492 }
9493 const double base_moves = u.run_cost( mcost, diag ) * 100.0 / crit->get_speed();
9494 const double encumb_moves = u.get_weight() / 4800.0_gram;
9495 u.moves -= static_cast<int>( std::ceil( base_moves + encumb_moves ) );
9496 if( u.movement_mode_is( CMM_WALK ) ) {
9497 crit->use_mech_power( -2 );
9498 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
9499 crit->use_mech_power( -1 );
9500 } else if( u.movement_mode_is( CMM_RUN ) ) {
9501 crit->use_mech_power( -3 );
9502 }
9503 } else {
9504 u.moves -= u.run_cost( mcost, diag );
9505 /**
9506 TODO:
9507 This should really use the mounted creatures stamina, if mounted.
9508 Monsters don't currently have stamina however.
9509 For the time being just don't burn players stamina when mounted.
9510 */
9511 if( grabbed_vehicle == nullptr || grabbed_vehicle->wheelcache.empty() ) {
9512 //Burn normal amount of stamina if no vehicle grabbed or vehicle lacks wheels
9513 u.burn_move_stamina( previous_moves - u.moves );
9514 } else {
9515 //Burn half as much stamina if vehicle has wheels, without changing move time
9516 u.burn_move_stamina( 0.50 * ( previous_moves - u.moves ) );
9517 }
9518 }
9519 // Max out recoil & reset aim point
9522
9523 // Print a message if movement is slow
9524 const int mcost_to = m.move_cost( dest_loc ); //calculate this _after_ calling grabbed_move
9525 const bool fungus = m.has_flag_ter_or_furn( "FUNGUS", u.pos() ) ||
9526 m.has_flag_ter_or_furn( "FUNGUS",
9527 dest_loc ); //fungal furniture has no slowing effect on mycus characters
9528 const bool slowed = ( ( !u.has_trait( trait_PARKOUR ) && ( mcost_to > 2 || mcost_from > 2 ) ) ||
9529 mcost_to > 4 || mcost_from > 4 ) &&
9530 !( u.has_trait( trait_M_IMMUNE ) && fungus );
9531 if( slowed && !u.is_mounted() ) {
9532 // Unless u.pos() has a higher movecost than dest_loc, state that dest_loc is the cause
9533 if( mcost_to >= mcost_from ) {
9534 if( auto displayed_part = vp_there.part_displayed() ) {
9535 add_msg( m_warning, _( "Moving onto this %s is slow!" ),
9536 displayed_part->part().name() );
9537 sfx::do_obstacle( displayed_part->part().info().get_id().str() );
9538 } else {
9539 add_msg( m_warning, _( "Moving onto this %s is slow!" ), m.name( dest_loc ) );
9540 sfx::do_obstacle( m.ter( dest_loc ).id().str() );
9541 }
9542 } else {
9543 if( auto displayed_part = vp_here.part_displayed() ) {
9544 add_msg( m_warning, _( "Moving off of this %s is slow!" ),
9545 displayed_part->part().name() );
9546 sfx::do_obstacle( displayed_part->part().info().get_id().str() );
9547 } else {
9548 add_msg( m_warning, _( "Moving off of this %s is slow!" ), m.name( u.pos() ) );
9549 sfx::do_obstacle( m.ter( u.pos() ).id().str() );
9550 }
9551 }
9552 }
9553 if( !u.is_mounted() && u.has_trait( trait_id( "LEG_TENT_BRACE" ) ) &&
9554 ( !u.footwear_factor() ||
9555 ( u.footwear_factor() == .5 && one_in( 2 ) ) ) ) {
9556 // DX and IN are long suits for Cephalopods,
9557 // so this shouldn't cause too much hardship
9558 // Presumed that if it's swimmable, they're
9559 // swimming and won't stick
9560 ///\EFFECT_DEX decreases chance of tentacles getting stuck to the ground
9561
9562 ///\EFFECT_INT decreases chance of tentacles getting stuck to the ground
9563 if( !m.has_flag( "SWIMMABLE", dest_loc ) && one_in( 80 + u.dex_cur + u.int_cur ) ) {
9564 add_msg( _( "Your tentacles stick to the ground, but you pull them free." ) );
9565 u.mod_fatigue( 1 );
9566 }
9567 }
9568 if( !u.has_artifact_with( AEP_STEALTH ) && !u.has_trait( trait_id( "DEBUG_SILENT" ) ) ) {
9569 int volume = u.is_stealthy() ? 3 : 6;
9570 volume *= u.mutation_value( "noise_modifier" );
9571 if( volume > 0 ) {
9573 volume = 2;
9574 } else if( u.has_bionic( bionic_id( "bio_ankles" ) ) ) {
9575 volume = 12;
9576 }
9577 if( u.movement_mode_is( CMM_RUN ) ) {
9578 volume *= 1.5;
9579 } else if( u.movement_mode_is( CMM_CROUCH ) ) {
9580 volume /= 2;
9581 }
9582 if( u.is_mounted() ) {
9583 auto mons = u.mounted_creature.get();
9584 switch( mons->get_size() ) {
9585 case MS_TINY:
9586 volume = 0; // No sound for the tinies
9587 break;
9588 case MS_SMALL:
9589 volume /= 3;
9590 break;
9591 case MS_MEDIUM:
9592 break;
9593 case MS_LARGE:
9594 volume *= 1.5;
9595 break;
9596 case MS_HUGE:
9597 volume *= 2;
9598 break;
9599 default:
9600 break;
9601 }
9602 if( mons->has_flag( MF_LOUDMOVES ) ) {
9603 volume += 6;
9604 }
9605 sounds::sound( dest_loc, volume, sounds::sound_t::movement, mons->type->get_footsteps(), false,
9606 "none", "none" );
9607 } else {
9608 sounds::sound( dest_loc, volume, sounds::sound_t::movement, _( "footsteps" ), true,
9609 "none", "none" ); // Sound of footsteps may awaken nearby monsters
9610 }
9612 }
9613
9614 if( one_in( 20 ) && u.has_artifact_with( AEP_MOVEMENT_NOISE ) ) {
9615 sounds::sound( u.pos(), 40, sounds::sound_t::movement, _( "a rattling sound." ), true,
9616 "misc", "rattling" );
9617 }
9618 }
9619
9620 if( m.has_flag_ter_or_furn( TFLAG_HIDE_PLACE, dest_loc ) ) {
9621 add_msg( m_good, _( "You are hiding in the %s." ), m.name( dest_loc ) );
9622 }
9623
9624 if( dest_loc != u.pos() ) {
9626 }
9627
9628 tripoint oldpos = u.pos();
9629 point submap_shift = place_player( dest_loc );
9630 point ms_shift = sm_to_ms_copy( submap_shift );
9631 oldpos = oldpos - ms_shift;
9632
9633 if( pulling ) {
9634 const tripoint shifted_furn_pos = furn_pos - ms_shift;
9635 const tripoint shifted_furn_dest = furn_dest - ms_shift;
9636 const time_duration fire_age = m.get_field_age( shifted_furn_pos, fd_fire );
9637 const int fire_intensity = m.get_field_intensity( shifted_furn_pos, fd_fire );
9638 m.remove_field( shifted_furn_pos, fd_fire );
9639 m.set_field_intensity( shifted_furn_dest, fd_fire, fire_intensity );
9640 m.set_field_age( shifted_furn_dest, fd_fire, fire_age );
9641 }
9642
9643 if( u.is_hauling() ) {
9644 start_hauling( oldpos );
9645 }
9646
9648
9649 return true;
9650}
void burn_move_stamina(int moves)
Definition: character.cpp:7237
virtual bool has_artifact_with(art_effect_passive effect) const
Definition: character.cpp:3223
units::mass get_weight() const override
Returns body weight plus weight of inventory and worn/wielded items.
Definition: character.cpp:3667
bool is_on_ground() const override
Returns true if the player is knocked over or has broken legs.
Definition: character.cpp:962
float mutation_value(const std::string &val) const
Goes over all mutations, gets min and max of a value with given name.
Definition: character.cpp:6765
int run_cost(int base_cost, bool diag=false) const
Returns the player's modified base movement cost.
m_size get_size() const override
Get size class of character.
Definition: character.cpp:541
bool grabbed_move(const tripoint &dp)
Check for dangerous stuff at dest_loc, return false if the player decides not to step there.
Definition: game.cpp:10256
bool is_dangerous_tile(const tripoint &dest_loc) const
Definition: game.cpp:9259
const string_id< T > & id() const
Definition: ammo_effect.cpp:33
int combined_movecost(const tripoint &from, const tripoint &to, const vehicle *ignored_vehicle=nullptr, int modifier=0, bool flying=false, bool via_ramp=false) const
Cost to move out of one tile and into the next.
Definition: map.cpp:1833
m_size get_size() const override
Definition: monster.cpp:2672
cata::optional< vpart_reference > part_displayed() const
Definition: vehicle.cpp:2498
bool is_stealthy() const
Returns true if the player has stealthy movement.
cata::optional< tripoint > last_target_pos
Definition: player.h:648
@ MS_TINY
Definition: creature.h:58
@ MS_LARGE
Definition: creature.h:61
@ MS_MEDIUM
Definition: creature.h:60
static const itype_id itype_rm13_armor_on("rm13_armor_on")
static const trait_id trait_M_IMMUNE("M_IMMUNE")
@ TFLAG_SMALL_PASSAGE
Definition: mapdata.h:320
@ TFLAG_HIDE_PLACE
Definition: mapdata.h:315
@ MF_LOUDMOVES
Definition: mtype.h:175
void fungus(player &p, const tripoint &examp)
Remove furniture.
Definition: iexamine.cpp:2147
void do_obstacle(const std::string &obst="")
Definition: sounds.cpp:1635
void do_footstep()
Definition: sounds.cpp:1612

References _, add_msg(), AEP_MOVEMENT_NOISE, AEP_STEALTH, cata_event_dispatch::avatar_moves(), Character::burn_move_stamina(), CMM_CROUCH, CMM_RUN, CMM_WALK, map::combined_movecost(), Character::dex_cur, sfx::do_footstep(), sfx::do_obstacle(), enumerate_as_string(), fd_fire, Character::footwear_factor(), iexamine::fungus(), map::furn(), get_dangerous_tile(), map::get_field_age(), map::get_field_intensity(), avatar::get_grab_type(), Character::get_size(), monster::get_size(), Character::get_weight(), avatar::grab(), player::grab_point, grabbed_move(), Character::has_artifact_with(), Character::has_bionic(), map::has_flag(), map::has_flag_ter(), map::has_flag_ter_or_furn(), map::has_furn(), Character::has_trait(), int_id< T >::id(), map::impassable(), Character::int_cur, is_dangerous_tile(), Character::is_hauling(), Character::is_mounted(), Character::is_on_ground(), player::is_stealthy(), Character::is_wearing(), itype_rm13_armor_on, player::last_target_pos, m, m_bad, m_good, m_warning, MAX_RECOIL, MF_LOUDMOVES, MF_RIDEABLE_MECH, Character::mod_fatigue(), Character::mounted_creature, map::move_cost(), map_data_common_t::movecost, sounds::movement, Character::movement_mode_is(), Creature::moves, MS_HUGE, MS_LARGE, MS_MEDIUM, MS_SMALL, MS_TINY, Character::mutation_value(), map::name(), cata::nullopt, int_id< T >::obj(), OBJECT_FURNITURE, OBJECT_NONE, OBJECT_VEHICLE, on_move_effects(), one_in(), optional_vpart_position::part_displayed(), place_player(), Character::pos(), Character::posx(), Character::posy(), Character::posz(), prompt_dangerous_tile(), Character::recoil, map::remove_field(), Character::run_cost(), map::set_field_age(), map::set_field_intensity(), player::set_underwater(), sm_to_ms_copy(), sounds::sound(), start_hauling(), string_id< T >::str(), map::ter(), TFLAG_HIDE_PLACE, TFLAG_SMALL_PASSAGE, trait_M_IMMUNE, trait_PARKOUR, trigdist, tripoint_zero, u, map::veh_at(), veh_pointer_or_null(), vehicle::wheelcache, tripoint::x, tripoint::xy(), tripoint::y, and tripoint::z.

Referenced by swap_critters().

◆ wield() [1/2]

void game::wield ( )
private

Definition at line 9119 of file game.cpp.

9120{
9122
9123 if( loc ) {
9124 wield( loc );
9125 } else {
9126 add_msg( _( "Never mind." ) );
9127 }
9128}
item_location wield(avatar &you)
Item wielding/unwielding menu.

References _, add_msg(), u, wield(), and game_menus::inv::wield().

Referenced by handle_action(), inventory_item_menu(), and wield().

◆ wield() [2/2]

void game::wield ( item_location loc)
private

Definition at line 9031 of file game.cpp.

9032{
9033 if( u.is_armed() ) {
9034 const bool is_unwielding = u.is_wielding( *loc );
9035 const auto ret = u.can_unwield( *loc );
9036
9037 if( !ret.success() ) {
9038 add_msg( m_info, "%s", ret.c_str() );
9039 }
9040
9041 u.unwield();
9042
9043 if( is_unwielding ) {
9044 if( !u.martial_arts_data->selected_is_none() ) {
9045 u.martial_arts_data->martialart_use_message( u );
9046 }
9047 return;
9048 }
9049 }
9050
9051 const auto ret = u.can_wield( *loc );
9052 if( !ret.success() ) {
9053 add_msg( m_info, "%s", ret.c_str() );
9054 }
9055
9056 // Need to do this here because holster_actor::use() checks if/where the item is worn
9057 item &target = *loc.get_item();
9058 if( target.get_use( "holster" ) && !target.contents.empty() ) {
9059 //~ %1$s: weapon name, %2$s: holster name
9060 if( query_yn( pgettext( "holster", "Draw %1$s from %2$s?" ), target.get_contained().tname(),
9061 target.tname() ) ) {
9062 u.invoke_item( &target );
9063 return;
9064 }
9065 }
9066
9067 // Can't use loc.obtain() here because that would cause things to spill.
9068 item to_wield = *loc.get_item();
9069 item_location::type location_type = loc.where();
9070 tripoint pos = loc.position();
9071 int worn_index = INT_MIN;
9072 if( u.is_worn( *loc.get_item() ) ) {
9073 auto ret = u.can_takeoff( *loc.get_item() );
9074 if( !ret.success() ) {
9075 add_msg( m_info, "%s", ret.c_str() );
9076 return;
9077 }
9078 int item_pos = u.get_item_position( loc.get_item() );
9079 if( item_pos != INT_MIN ) {
9080 worn_index = Character::worn_position_to_index( item_pos );
9081 }
9082 }
9083 loc.remove_item();
9084 if( !u.wield( to_wield ) ) {
9085 switch( location_type ) {
9087 // this will not cause things to spill, as it is inside another item
9088 loc = loc.obtain( g->u );
9089 wield( loc );
9090 break;
9092 if( worn_index != INT_MIN ) {
9093 auto it = u.worn.begin();
9094 std::advance( it, worn_index );
9095 u.worn.insert( it, to_wield );
9096 } else {
9097 u.i_add( to_wield );
9098 }
9099 break;
9101 m.add_item( pos, to_wield );
9102 break;
9104 const cata::optional<vpart_reference> vp = m.veh_at( pos ).part_with_feature( "CARGO", false );
9105 // If we fail to return the item to the vehicle for some reason, add it to the map instead.
9106 if( !vp || !( vp->vehicle().add_item( vp->part_index(), to_wield ) ) ) {
9107 m.add_item( pos, to_wield );
9108 }
9109 break;
9110 }
9112 debugmsg( "Failed wield from invalid item location" );
9113 break;
9114 }
9115 return;
9116 }
9117}
std::list< item > worn
Definition: character.h:1515
static int worn_position_to_index(int position)
Definition: character.h:1079
item & i_add(item it, bool should_stack=true)
Definition: character.cpp:2324
bool wield(item &target) override
Removes currently wielded item (if any) and replaces it with the target item.
Definition: avatar.cpp:1185
type where() const
Returns the type of location where the item is found.
void remove_item()
Removes the selected item from the game.
tripoint position() const
Returns the position where the item is found.
const item & get_contained() const
Return a contained item (if any and only one).
Definition: item.cpp:6884
item & add_item(const tripoint &p, item new_item)
Place an item on the map, despite the parameter name, this is not necessarily a new item.
Definition: map.cpp:4314
ret_val< bool > can_wield(const item &it) const
Check player capable of wielding an item.
Definition: player.cpp:2386
bool unwield()
Definition: player.cpp:2425

References map::add_item(), add_msg(), player::can_takeoff(), Character::can_unwield(), player::can_wield(), item_location::character, item_location::container, item::contents, debugmsg, item_contents::empty(), g, item::get_contained(), item_location::get_item(), Character::get_item_position(), item::get_use(), Character::i_add(), item_location::invalid, avatar::invoke_item(), Character::is_armed(), Character::is_wielding(), Character::is_worn(), m, m_info, item_location::map, Character::martial_arts_data, item_location::obtain(), optional_vpart_position::part_with_feature(), pgettext(), item_location::position(), query_yn(), item_location::remove_item(), cata::hash64_detail::ret, item::tname(), u, player::unwield(), map::veh_at(), item_location::vehicle, item_location::where(), wield(), avatar::wield(), Character::worn, and Character::worn_position_to_index().

◆ win()

void game::win ( )

Marks the game as won.

Doesn't end the game.

Definition at line 2748 of file game.cpp.

2749{
2750 win_screen();
2752 memorial().add(
2753 pgettext( "memorial_male", "Closed the portal in %1$.1f days (%2$d seconds)." ),
2754 pgettext( "memorial_female", "Closed the portal in %1$.1f days (%2$d seconds)." ),
2755 to_days<float>( game_duration ), to_seconds<int>( game_duration ) );
2756 if( !u.is_dead_state() ) {
2759 }
2760}
void win_screen()
Definition: game.cpp:2762
void add(const std::string &male_msg, const std::string &female_msg)
Adds an event to the memorial log, to be written to the memorial file when the character dies.
const time_point & start_of_game
Definition: calendar.cpp:34

References achievements_tracker_ptr, memorial_logger::add(), Messages::display_messages(), get_kill_tracker(), player::is_dead_state(), memorial(), pgettext(), show_scores_ui(), calendar::start_of_game, stats(), calendar::turn, u, and win_screen().

◆ win_screen()

void game::win_screen ( )
private

Definition at line 2762 of file game.cpp.

2763{
2764 // TODO: Move this wall somewhere
2766 std::string msg = _( "You managed to close the portal and end the invasion!" );
2767 msg += '\n';
2768 if( u.is_dead_state() ) {
2770 "Unfortunately, you had to sacrifice your life to achieve this." );
2771 msg += colorize( t, c_red ) + '\n';
2772 memorial().add(
2773 pgettext( "memorial_male", "Sacrificed his life to close the portal." ),
2774 pgettext( "memorial_female", "Sacrificed her life to close the portal." ) );
2775 } else {
2776 translation t = translation::to_translation( "win_game", "You managed to survive the ordeal." );
2777 msg += colorize( t, c_green ) + '\n';
2778 memorial().add(
2779 pgettext( "memorial_male", "Safely closed the portal." ),
2780 pgettext( "memorial_female", "Safely closed the portal." ) );
2781 }
2782 msg += string_format( _( "It took you %1$.1f days (%2$d seconds)." ),
2783 to_days<float>( game_duration ), to_seconds<int>( game_duration ) );
2784 // TODO: Print starting stats, traits, skills, all mods ever used, easiest of settings
2785 popup( msg );
2786}
Class for storing translation context and raw string for deferred translation.
Definition: translations.h:152
static translation to_translation(const std::string &raw)
Store a string, an optional plural form, and an optional context for translation.
std::string colorize(const std::string &text, const nc_color &color)
Definition: color.cpp:669

References _, memorial_logger::add(), c_green, c_red, colorize(), player::is_dead_state(), memorial(), pgettext(), popup(), calendar::start_of_game, string_format(), translation::to_translation(), calendar::turn, and u.

Referenced by win().

◆ write_memorial_file()

void game::write_memorial_file ( const std::string &  filename,
std::string  sLastWords 
)

Writes information about the character out to a text file timestamped with the time of the file was made.

This serves as a record of the character's state at the time the memorial was made (usually upon death) and accomplishments in a human-readable format.

Definition at line 3151 of file game.cpp.

3152{
3153 const std::string &memorial_dir = PATH_INFO::memorialdir();
3154 const std::string &memorial_active_world_dir = memorial_dir +
3155 world_generator->active_world->world_name + "/";
3156
3157 //Check if both dirs exist. Nested assure_dir_exist fails if the first dir of the nested dir does not exist.
3158 if( !assure_dir_exist( memorial_dir ) ) {
3159 debugmsg( "Could not make '%s' directory", memorial_dir );
3160 return;
3161 }
3162
3163 if( !assure_dir_exist( memorial_active_world_dir ) ) {
3164 debugmsg( "Could not make '%s' directory", memorial_active_world_dir );
3165 return;
3166 }
3167
3168 std::string path = memorial_active_world_dir + filename + ".txt";
3169
3170 write_to_file( path, [&]( std::ostream & fout ) {
3171 memorial().write( fout, sLastWords );
3172 }, _( "player memorial" ) );
3173}
void write(std::ostream &memorial_file, const std::string &epitaph) const
std::string memorialdir()
Definition: path_info.cpp:226

References _, assure_dir_exist(), debugmsg, memorial(), PATH_INFO::memorialdir(), world_generator, memorial_logger::write(), and write_to_file().

Referenced by cleanup_at_end().

◆ zones_manager()

void game::zones_manager ( )

Definition at line 6385 of file game.cpp.

6386{
6387 const tripoint stored_view_offset = u.view_offset;
6388
6390
6391 const int zone_ui_height = 12;
6392 const int zone_options_height = 7;
6393
6394 const int width = 45;
6395
6396 int offsetX = 0;
6397 int max_rows = 0;
6398
6399 catacurses::window w_zones;
6400 catacurses::window w_zones_border;
6401 catacurses::window w_zones_info;
6402 catacurses::window w_zones_info_border;
6403 catacurses::window w_zones_options;
6404
6405 bool show = true;
6406
6407 ui_adaptor ui;
6408 ui.on_screen_resize( [&]( ui_adaptor & ui ) {
6409 if( !show ) {
6410 ui.position( point_zero, point_zero );
6411 return;
6412 }
6413 offsetX = get_option<std::string>( "SIDEBAR_POSITION" ) != "left" ?
6414 TERMX - width : 0;
6415 const int w_zone_height = TERMY - zone_ui_height;
6416 max_rows = w_zone_height - 2;
6417 w_zones = catacurses::newwin( w_zone_height - 2, width - 2,
6418 point( offsetX + 1, 1 ) );
6419 w_zones_border = catacurses::newwin( w_zone_height, width,
6420 point( offsetX, 0 ) );
6421 w_zones_info = catacurses::newwin( zone_ui_height - zone_options_height - 1,
6422 width - 2, point( offsetX + 1, w_zone_height ) );
6423 w_zones_info_border = catacurses::newwin( zone_ui_height, width,
6424 point( offsetX, w_zone_height ) );
6425 w_zones_options = catacurses::newwin( zone_options_height - 1, width - 2,
6426 point( offsetX + 1, TERMY - zone_options_height ) );
6427
6428 ui.position( point( offsetX, 0 ), point( width, TERMY ) );
6429 } );
6430 ui.mark_resize();
6431
6432 std::string action;
6433 input_context ctxt( "ZONES_MANAGER" );
6434 ctxt.register_cardinal();
6435 ctxt.register_action( "CONFIRM" );
6436 ctxt.register_action( "QUIT" );
6437 ctxt.register_action( "ADD_ZONE" );
6438 ctxt.register_action( "REMOVE_ZONE" );
6439 ctxt.register_action( "MOVE_ZONE_UP" );
6440 ctxt.register_action( "MOVE_ZONE_DOWN" );
6441 ctxt.register_action( "SHOW_ZONE_ON_MAP" );
6442 ctxt.register_action( "ENABLE_ZONE" );
6443 ctxt.register_action( "DISABLE_ZONE" );
6444 ctxt.register_action( "SHOW_ALL_ZONES" );
6445 ctxt.register_action( "HELP_KEYBINDINGS" );
6446
6447 auto &mgr = zone_manager::get_manager();
6448 int start_index = 0;
6449 int active_index = 0;
6450 bool blink = false;
6451 bool stuff_changed = false;
6452 bool show_all_zones = false;
6453 int zone_cnt = 0;
6454
6455 // get zones on the same z-level, with distance between player and
6456 // zone center point <= 50 or all zones, if show_all_zones is true
6457 auto get_zones = [&]() {
6458 std::vector<zone_manager::ref_zone_data> zones;
6459 if( show_all_zones ) {
6460 zones = mgr.get_zones();
6461 } else {
6462 const tripoint &u_abs_pos = m.getabs( u.pos() );
6463 for( zone_manager::ref_zone_data &ref : mgr.get_zones() ) {
6464 const tripoint &zone_abs_pos = ref.get().get_center_point();
6465 if( u_abs_pos.z == zone_abs_pos.z && rl_dist( u_abs_pos, zone_abs_pos ) <= 50 ) {
6466 zones.emplace_back( ref );
6467 }
6468 }
6469 }
6470 zone_cnt = static_cast<int>( zones.size() );
6471 return zones;
6472 };
6473
6474 auto zones = get_zones();
6475
6476 auto zones_manager_options = [&]() {
6477 werase( w_zones_options );
6478
6479 if( zone_cnt > 0 ) {
6480 const auto &zone = zones[active_index].get();
6481
6482 if( zone.has_options() ) {
6483 const auto &descriptions = zone.get_options().get_descriptions();
6484
6485 // NOLINTNEXTLINE(cata-use-named-point-constants)
6486 mvwprintz( w_zones_options, point( 1, 0 ), c_white, _( "Options" ) );
6487
6488 int y = 1;
6489 for( const auto &desc : descriptions ) {
6490 mvwprintz( w_zones_options, point( 3, y ), c_white, desc.first );
6491 mvwprintz( w_zones_options, point( 20, y ), c_white, desc.second );
6492 y++;
6493 }
6494 }
6495 }
6496
6497 wnoutrefresh( w_zones_options );
6498 };
6499
6500 cata::optional<tripoint> zone_start;
6501 cata::optional<tripoint> zone_end;
6502 bool zone_blink = false;
6503 bool zone_cursor = false;
6505 zone_start, zone_end, zone_blink, zone_cursor );
6506 add_draw_callback( zone_cb );
6507
6508 auto query_position =
6509 [&]() -> cata::optional<std::pair<tripoint, tripoint>> {
6510 on_out_of_scope invalidate_current_ui( [&]()
6511 {
6512 ui.mark_resize();
6513 } );
6514 restore_on_out_of_scope<bool> show_prev( show );
6515 restore_on_out_of_scope<cata::optional<tripoint>> zone_start_prev( zone_start );
6516 restore_on_out_of_scope<cata::optional<tripoint>> zone_end_prev( zone_end );
6517 show = false;
6518 zone_start = cata::nullopt;
6519 zone_end = cata::nullopt;
6520 ui.mark_resize();
6521
6523 popup.on_top( true );
6524 popup.message( "%s", _( "Select first point." ) );
6525
6527
6528 const look_around_result first = look_around( /*show_window=*/false, center, center, false, true,
6529 false );
6530 if( first.position )
6531 {
6532 popup.message( "%s", _( "Select second point." ) );
6533
6534 const look_around_result second = look_around( /*show_window=*/false, center, *first.position,
6535 true, true, false );
6536 if( second.position ) {
6537 tripoint first_abs = m.getabs( tripoint( std::min( first.position->x,
6538 second.position->x ),
6539 std::min( first.position->y, second.position->y ),
6540 std::min( first.position->z,
6541 second.position->z ) ) );
6542 tripoint second_abs = m.getabs( tripoint( std::max( first.position->x,
6543 second.position->x ),
6544 std::max( first.position->y, second.position->y ),
6545 std::max( first.position->z,
6546 second.position->z ) ) );
6547 return std::pair<tripoint, tripoint>( first_abs, second_abs );
6548 }
6549 }
6550
6551 return cata::nullopt;
6552 };
6553
6554 ui.on_redraw( [&]( const ui_adaptor & ) {
6555 if( !show ) {
6556 return;
6557 }
6558 zones_manager_draw_borders( w_zones_border, w_zones_info_border, zone_ui_height, width );
6559 zones_manager_shortcuts( w_zones_info );
6560
6561 if( zone_cnt == 0 ) {
6562 werase( w_zones );
6563 mvwprintz( w_zones, point( 2, 5 ), c_white, _( "No Zones defined." ) );
6564
6565 } else {
6566 werase( w_zones );
6567
6568 calcStartPos( start_index, active_index, max_rows, zone_cnt );
6569
6570 draw_scrollbar( w_zones_border, active_index, max_rows, zone_cnt, point_south );
6571 wnoutrefresh( w_zones_border );
6572
6573 int iNum = 0;
6574
6575 tripoint player_absolute_pos = m.getabs( u.pos() );
6576
6577 //Display saved zones
6578 for( auto &i : zones ) {
6579 if( iNum >= start_index &&
6580 iNum < start_index + ( ( max_rows > zone_cnt ) ? zone_cnt : max_rows ) ) {
6581 const auto &zone = i.get();
6582
6583 nc_color colorLine = ( zone.get_enabled() ) ? c_white : c_light_gray;
6584
6585 if( iNum == active_index ) {
6586 mvwprintz( w_zones, point( 0, iNum - start_index ), c_yellow, "%s", ">>" );
6587 colorLine = ( zone.get_enabled() ) ? c_light_green : c_green;
6588 }
6589
6590 //Draw Zone name
6591 mvwprintz( w_zones, point( 3, iNum - start_index ), colorLine,
6592 trim_by_length( zone.get_name(), 15 ) );
6593
6594 //Draw Type name
6595 mvwprintz( w_zones, point( 20, iNum - start_index ), colorLine,
6596 mgr.get_name_from_type( zone.get_type() ) );
6597
6598 tripoint center = zone.get_center_point();
6599
6600 //Draw direction + distance
6601 mvwprintz( w_zones, point( 32, iNum - start_index ), colorLine, "%*d %s",
6602 5, static_cast<int>( trig_dist( player_absolute_pos, center ) ),
6603 direction_name_short( direction_from( player_absolute_pos,
6604 center ) ) );
6605
6606 //Draw Vehicle Indicator
6607 mvwprintz( w_zones, point( 41, iNum - start_index ), colorLine,
6608 zone.get_is_vehicle() ? "*" : "" );
6609 }
6610 iNum++;
6611 }
6612
6613 // Display zone options
6614 zones_manager_options();
6615 }
6616
6617 wnoutrefresh( w_zones );
6618 } );
6619
6620 zones_manager_open = true;
6621 do {
6622 if( action == "ADD_ZONE" ) {
6623 do { // not a loop, just for quick bailing out if canceled
6624 const auto maybe_id = mgr.query_type();
6625 if( !maybe_id.has_value() ) {
6626 break;
6627 }
6628
6629 const zone_type_id &id = maybe_id.value();
6630 auto options = zone_options::create( id );
6631
6632 if( !options->query_at_creation() ) {
6633 break;
6634 }
6635
6636 auto default_name = options->get_zone_name_suggestion();
6637 if( default_name.empty() ) {
6638 default_name = mgr.get_name_from_type( id );
6639 }
6640 const auto maybe_name = mgr.query_name( default_name );
6641 if( !maybe_name.has_value() ) {
6642 break;
6643 }
6644 const std::string &name = maybe_name.value();
6645
6646 const auto position = query_position();
6647 if( !position ) {
6648 break;
6649 }
6650
6651 mgr.add( name, id, g->u.get_faction()->id, false, true, position->first,
6652 position->second, options );
6653
6654 zones = get_zones();
6655 active_index = zone_cnt - 1;
6656
6657 stuff_changed = true;
6658 } while( false );
6659
6660 blink = false;
6661 } else if( action == "SHOW_ALL_ZONES" ) {
6662 show_all_zones = !show_all_zones;
6663 zones = get_zones();
6664 active_index = 0;
6665 } else if( zone_cnt > 0 ) {
6666 if( action == "UP" ) {
6667 active_index--;
6668 if( active_index < 0 ) {
6669 active_index = zone_cnt - 1;
6670 }
6671 blink = false;
6672 } else if( action == "DOWN" ) {
6673 active_index++;
6674 if( active_index >= zone_cnt ) {
6675 active_index = 0;
6676 }
6677 blink = false;
6678 } else if( action == "REMOVE_ZONE" ) {
6679 if( active_index < zone_cnt ) {
6680 mgr.remove( zones[active_index] );
6681 zones = get_zones();
6682 active_index--;
6683
6684 if( active_index < 0 ) {
6685 active_index = 0;
6686 }
6687 }
6688 blink = false;
6689 stuff_changed = true;
6690
6691 } else if( action == "CONFIRM" ) {
6692 auto &zone = zones[active_index].get();
6693
6694 uilist as_m;
6695 as_m.text = _( "What do you want to change:" );
6696 as_m.entries.emplace_back( 1, true, '1', _( "Edit name" ) );
6697 as_m.entries.emplace_back( 2, true, '2', _( "Edit type" ) );
6698 as_m.entries.emplace_back( 3, zone.get_options().has_options(), '3',
6699 zone.get_type() == zone_type_id( "LOOT_CUSTOM" ) ? _( "Edit filter" ) : _( "Edit options" ) );
6700 as_m.entries.emplace_back( 4, !zone.get_is_vehicle(), '4', _( "Edit position" ) );
6701 // TODO: Enable moving vzone after vehicle zone can be bigger than 1*1
6702 as_m.entries.emplace_back( 5, !zone.get_is_vehicle(), '5', _( "Move position" ) );
6703 as_m.query();
6704
6705 switch( as_m.ret ) {
6706 case 1:
6707 if( zone.set_name() ) {
6708 stuff_changed = true;
6709 }
6710 break;
6711 case 2:
6712 if( zone.set_type() ) {
6713 stuff_changed = true;
6714 }
6715 break;
6716 case 3:
6717 if( zone.get_options().query() ) {
6718 stuff_changed = true;
6719 }
6720 break;
6721 case 4: {
6722 const auto pos = query_position();
6723 if( pos && ( pos->first != zone.get_start_point() ||
6724 pos->second != zone.get_end_point() ) ) {
6725 zone.set_position( *pos );
6726 stuff_changed = true;
6727 }
6728 break;
6729 }
6730 case 5: {
6731 on_out_of_scope invalidate_current_ui( [&]() {
6732 ui.mark_resize();
6733 } );
6734 restore_on_out_of_scope<bool> show_prev( show );
6735 restore_on_out_of_scope<cata::optional<tripoint>> zone_start_prev( zone_start );
6736 restore_on_out_of_scope<cata::optional<tripoint>> zone_end_prev( zone_end );
6737 show = false;
6738 zone_start = cata::nullopt;
6739 zone_end = cata::nullopt;
6740 ui.mark_resize();
6741 static_popup message_pop;
6742 message_pop.on_top( true );
6743 message_pop.message( "%s", _( "Moving zone." ) );
6744 const auto zone_local_start_point = m.getlocal( zone.get_start_point() );
6745 const auto zone_local_end_point = m.getlocal( zone.get_end_point() );
6746 // local position of the zone center, used to calculate the u.view_offset,
6747 // could center the screen to the position it represents
6748 auto view_center = m.getlocal( zone.get_center_point() );
6749 const look_around_result result_local = look_around( false, view_center,
6750 zone_local_start_point, false, false,
6751 false, true, zone_local_end_point );
6752 if( result_local.position ) {
6753 const auto new_start_point = m.getabs( *result_local.position );
6754 if( new_start_point == zone.get_start_point() ) {
6755 break; // Nothing changed, don't save
6756 }
6757
6758 const auto new_end_point = zone.get_end_point() - zone.get_start_point() + new_start_point;
6759 zone.set_position( std::pair<tripoint, tripoint>( new_start_point, new_end_point ) );
6760 stuff_changed = true;
6761 }
6762 }
6763 break;
6764 default:
6765 break;
6766 }
6767
6768 blink = false;
6769 } else if( action == "MOVE_ZONE_UP" && zone_cnt > 1 ) {
6770 if( active_index < zone_cnt - 1 ) {
6771 mgr.swap( zones[active_index], zones[active_index + 1] );
6772 zones = get_zones();
6773 active_index++;
6774 }
6775 blink = false;
6776 stuff_changed = true;
6777
6778 } else if( action == "MOVE_ZONE_DOWN" && zone_cnt > 1 ) {
6779 if( active_index > 0 ) {
6780 mgr.swap( zones[active_index], zones[active_index - 1] );
6781 zones = get_zones();
6782 active_index--;
6783 }
6784 blink = false;
6785 stuff_changed = true;
6786
6787 } else if( action == "SHOW_ZONE_ON_MAP" ) {
6788 //show zone position on overmap;
6789 tripoint_abs_omt player_overmap_position = u.global_omt_location();
6790 // TODO: fix point types
6791 tripoint_abs_omt zone_overmap( ms_to_omt_copy( zones[active_index].get().get_center_point() ) );
6792
6793 ui::omap::display_zones( player_overmap_position, zone_overmap, active_index );
6794 } else if( action == "ENABLE_ZONE" ) {
6795 zones[active_index].get().set_enabled( true );
6796
6797 stuff_changed = true;
6798
6799 } else if( action == "DISABLE_ZONE" ) {
6800 zones[active_index].get().set_enabled( false );
6801
6802 stuff_changed = true;
6803 }
6804 }
6805
6806 if( zone_cnt > 0 ) {
6807 blink = !blink;
6808 const auto &zone = zones[active_index].get();
6809 zone_start = m.getlocal( zone.get_start_point() );
6810 zone_end = m.getlocal( zone.get_end_point() );
6811 ctxt.set_timeout( BLINK_SPEED );
6812 } else {
6813 blink = false;
6814 zone_start = zone_end = cata::nullopt;
6815 ctxt.reset_timeout();
6816 }
6817
6818 // Actually accessed from the terrain overlay callback `zone_cb` in the
6819 // call to `ui_manager::redraw`.
6820 //NOLINTNEXTLINE(clang-analyzer-deadcode.DeadStores)
6821 zone_blink = blink;
6823
6825
6826 //Wait for input
6827 action = ctxt.handle_input();
6828 } while( action != "QUIT" );
6829 zones_manager_open = false;
6830 ctxt.reset_timeout();
6831 zone_cb = nullptr;
6832
6833 if( stuff_changed ) {
6834 auto &zones = zone_manager::get_manager();
6835 if( query_yn( _( "Save changes?" ) ) ) {
6836 zones.save_zones();
6837 } else {
6838 zones.load_zones();
6839 }
6840
6841 zones.cache_data();
6842 }
6843
6844 u.view_offset = stored_view_offset;
6845}
query_popup & on_top(bool top)
Whether to show the popup on the top of the screen.
Definition: popup.cpp:59
std::reference_wrapper< zone_data > ref_zone_data
Definition: clzones.h:345
static shared_ptr_fast< zone_options > create(const zone_type_id &type)
Definition: clzones.cpp:185
int trig_dist(const coords::coord_point< Point, Origin, Scale > &loc1, const coords::coord_point< Point, Origin, Scale > &loc2)
Definition: coordinates.h:512
static void zones_manager_shortcuts(const catacurses::window &w_info)
Definition: game.cpp:6320
static void zones_manager_draw_borders(const catacurses::window &w_border, const catacurses::window &w_info_border, const int iInfoHeight, const int width)
Definition: game.cpp:6343
std::string options()
Definition: path_info.cpp:238
const std::set< itype_id > & get()
void display_zones(const tripoint_abs_omt &center, const tripoint_abs_omt &select, int iZoneIndex)
Display overmap like with display() and display the given zone.
std::string trim_by_length(const std::string &text, int width)
Definition: output.cpp:224
cata::optional< tripoint > position
Definition: game.h:127

References _, action, add_draw_callback(), BLINK_SPEED, c_green, c_light_gray, c_light_green, c_white, c_yellow, calcStartPos(), center, zone_options::create(), create_zone_callback(), direction_from(), direction_name_short(), ui::omap::display_zones(), draw_scrollbar(), uilist::entries, g, charge_removal_blacklist::get(), zone_manager::get_manager(), map::getabs(), map::getlocal(), Character::global_omt_location(), input_context::handle_input(), invalidate_main_ui_adaptor(), look_around(), m, query_popup::message(), ms_to_omt_copy(), mvwprintz(), om_direction::name(), catacurses::newwin(), cata::nullopt, query_popup::on_top(), PATH_INFO::options(), point_south, point_zero, popup(), Character::pos(), look_around_result::position, uilist::query(), query_yn(), ui_manager::redraw(), input_context::register_action(), input_context::register_cardinal(), input_context::reset_timeout(), uilist::ret, rl_dist(), second, input_context::set_timeout(), TERMX, TERMY, uilist::text, trig_dist(), trim_by_length(), tripoint_zero, u, player::view_offset, catacurses::werase(), catacurses::wnoutrefresh(), tripoint::z, zones_manager_draw_borders(), zones_manager_open, and zones_manager_shortcuts().

Referenced by handle_action().

◆ zoom_in()

void game::zoom_in ( )

Definition at line 7339 of file game.cpp.

7340{
7341#if defined(TILES)
7342 if( tileset_zoom == 64 ) {
7343 tileset_zoom = MAXIMUM_ZOOM_LEVEL;
7344 } else {
7346 }
7347 rescale_tileset( tileset_zoom );
7348#endif
7349}

References tileset_zoom.

Referenced by handle_action(), and look_around().

◆ zoom_out()

void game::zoom_out ( )

Definition at line 7327 of file game.cpp.

7328{
7329#if defined(TILES)
7330 if( tileset_zoom > MAXIMUM_ZOOM_LEVEL ) {
7332 } else {
7333 tileset_zoom = 64;
7334 }
7335 rescale_tileset( tileset_zoom );
7336#endif
7337}

References tileset_zoom.

Referenced by handle_action(), and look_around().

Friends And Related Function Documentation

◆ advanced_inventory

friend class advanced_inventory
friend

Definition at line 146 of file game.h.

◆ Creature_range

friend class Creature_range
friend

Definition at line 360 of file game.h.

Referenced by all_creatures().

◆ editmap

friend class editmap
friend

Definition at line 145 of file game.h.

◆ get_avatar

avatar & get_avatar ( )
friend

Definition at line 102 of file avatar.cpp.

103{
104 return g->u;
105}

◆ get_distribution_grid_tracker

distribution_grid_tracker & get_distribution_grid_tracker ( )
friend

Returns distribution grid tracker that is a part of the global game *g.

game TODO: This wouldn't be required in an ideal world

Definition at line 12624 of file game.cpp.

12625{
12626 return *g->grid_tracker_ptr;
12627}

◆ get_map

map & get_map ( )
friend

Definition at line 142 of file map.cpp.

143{
144 return g->m;
145}

Referenced by check_art_charge_req(), extended_description(), find_empty_spot_nearby(), get_fire_fuel_string(), and print_terrain_info().

◆ get_player_character

Character & get_player_character ( )
friend

Definition at line 387 of file character.cpp.

388{
389 return g->u;
390}

◆ get_weather

weather_manager & get_weather ( )
friend

Definition at line 64 of file weather.cpp.

65{
66 return *g->weather_manager_ptr;
67}

Referenced by do_turn(), get_player_input(), is_in_sunlight(), load(), natural_light_level(), place_player_overmap(), serialize_master(), setup(), start_game(), and unserialize_master().

◆ main_menu

friend class main_menu
friend

Definition at line 147 of file game.h.

◆ monster_range

friend class monster_range
friend

Definition at line 359 of file game.h.

Referenced by all_monsters().

Member Data Documentation

◆ achievements_tracker_ptr

pimpl<achievements_tracker> game::achievements_tracker_ptr
private

Definition at line 1003 of file game.h.

Referenced by death_screen(), game(), handle_action(), serialize(), setup(), unserialize(), and win().

◆ active_npc

◆ auto_travel_mode

bool game::auto_travel_mode = false

Definition at line 1066 of file game.h.

Referenced by handle_action(), serialize(), and unserialize().

◆ bVMonsterLookFire

bool game::bVMonsterLookFire = false
private

Definition at line 1083 of file game.h.

Referenced by list_monsters(), look_around(), and setup().

◆ coming_to_stairs

std::vector<monster> game::coming_to_stairs

◆ critter_died

bool game::critter_died = false
private

Has anything died in this turn and needs to be cleaned up?

Definition at line 1097 of file game.h.

Referenced by cleanup_dead(), and set_critter_died().

◆ critter_tracker

◆ debug_hour_timer

◆ debug_pathfinding

bool game::debug_pathfinding = false

Definition at line 1047 of file game.h.

◆ debug_submap_grid_overlay

bool game::debug_submap_grid_overlay = false

Definition at line 1048 of file game.h.

◆ destination_preview

std::vector<tripoint> game::destination_preview
private

◆ displaying_lighting_condition

int game::displaying_lighting_condition = 0

Type of lighting condition overlay to display.

Definition at line 1060 of file game.h.

◆ displaying_overlays

cata::optional<action_id> game::displaying_overlays
private

Definition at line 967 of file game.h.

Referenced by display_overlay_state(), and display_toggle_overlay().

◆ displaying_visibility_creature

Creature* game::displaying_visibility_creature

Creature for which to display the visibility map.

Definition at line 1058 of file game.h.

Referenced by display_visibility().

◆ draw_callbacks

std::vector<weak_ptr_fast<draw_callback_t> > game::draw_callbacks
private

Definition at line 251 of file game.h.

Referenced by add_draw_callback(), and draw().

◆ driving_view_offset

point game::driving_view_offset

Definition at line 1045 of file game.h.

Referenced by calc_driving_offset(), do_turn(), handle_action(), and set_driving_view_offset().

◆ event_bus_ptr

pimpl<event_bus> game::event_bus_ptr
private

Definition at line 1001 of file game.h.

Referenced by events().

◆ faction_manager_ptr

◆ first_redraw_since_waiting_started

bool game::first_redraw_since_waiting_started = true
private

Is this the first redraw since waiting (sleeping or activity) started.

Definition at line 1099 of file game.h.

Referenced by do_turn(), and game().

◆ follower_ids

std::set<character_id> game::follower_ids
private

◆ fullscreen

bool game::fullscreen = false

◆ gamemode

std::unique_ptr<special_game> game::gamemode
private

◆ grid_tracker_ptr

pimpl<distribution_grid_tracker> game::grid_tracker_ptr
private

Definition at line 1007 of file game.h.

Referenced by do_turn(), load_map(), on_options_changed(), and update_map().

◆ is_looking

bool game::is_looking = false
private

Definition at line 250 of file game.h.

Referenced by draw_ter(), and look_around().

◆ kill_tracker_ptr

pimpl<kill_tracker> game::kill_tracker_ptr
private

Definition at line 1004 of file game.h.

Referenced by game(), get_kill_tracker(), serialize(), setup(), and unserialize().

◆ last_mouse_edge_scroll

std::chrono::time_point<std::chrono::steady_clock> game::last_mouse_edge_scroll
private

Definition at line 1116 of file game.h.

Referenced by mouse_edge_scrolling().

◆ last_mouse_edge_scroll_vector_overmap

tripoint game::last_mouse_edge_scroll_vector_overmap
private

Definition at line 1118 of file game.h.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ last_mouse_edge_scroll_vector_terrain

tripoint game::last_mouse_edge_scroll_vector_terrain
private

Definition at line 1117 of file game.h.

Referenced by mouse_edge_scrolling_overmap(), and mouse_edge_scrolling_terrain().

◆ last_save_timestamp

time_t game::last_save_timestamp
private

Definition at line 1089 of file game.h.

Referenced by autosave(), init_autosave(), and quicksave().

◆ latest_lightlevels

std::array<float, OVERMAP_LAYERS> game::latest_lightlevels
mutableprivate

Definition at line 1090 of file game.h.

Referenced by natural_light_level(), and reset_light_level().

◆ list_item_downvote

std::string game::list_item_downvote
private

Definition at line 1080 of file game.h.

Referenced by list_items().

◆ list_item_upvote

std::string game::list_item_upvote
private

Definition at line 1079 of file game.h.

Referenced by list_items().

◆ liveview

live_view& game::liveview
private

Definition at line 998 of file game.h.

Referenced by draw_look_around_cursor(), and handle_mouseview().

◆ liveview_ptr

pimpl<live_view> game::liveview_ptr
private

Definition at line 997 of file game.h.

◆ m

map& game::m

Definition at line 1011 of file game.h.

Referenced by autopilot_vehicles(), cata_event_dispatch::avatar_moves(), butcher(), catch_a_monster(), check_near_zone(), check_zone(), control_vehicle(), disable_robot(), disp_NPCs(), do_turn(), draw(), draw_bullet(), draw_critter(), draw_critter_highlighted(), draw_critter_internal(), draw_hit_mon(), draw_look_around_cursor(), draw_ter(), examine(), extended_description(), find_nearby_items(), find_or_make_stairs(), fling_creature(), forced_door_closing(), get_cur_om(), get_dangerous_tile(), get_fishable_locations(), get_levx(), get_levy(), get_levz(), get_player_input(), get_veh_dir_indicator_location(), grabbed_furn_move(), grabbed_veh_move(), handle_action(), is_empty(), is_game_over(), is_in_sunlight(), is_sheltered(), knockback(), list_items(), list_monsters(), load(), load_map(), load_npcs(), look_around(), mon_info_update(), monmove(), moving_vehicle_dismount(), peek(), perhaps_add_random_npc(), phasing_move(), pickup(), place_critter_around(), place_player(), place_player_overmap(), place_vehicle_nearby(), pre_print_all_tile_info(), print_all_tile_info(), print_fields_info(), print_graffiti_info(), print_items_info(), print_terrain_info(), print_trap_info(), process_artifact(), prompt_dangerous_tile(), remoteveh(), save_cyborg(), save_maps(), serialize(), setup(), shift_monsters(), start_game(), start_hauling(), swap_critters(), try_get_left_click_action(), try_get_right_click_action(), update_map(), update_stair_monsters(), use_computer(), validate_camps(), validate_linked_vehicles(), validate_mounted_npcs(), vertical_move(), vertical_notes(), vertical_shift(), walk_move(), wield(), and zones_manager().

◆ main_ui_adaptor

weak_ptr_fast<ui_adaptor> game::main_ui_adaptor
private

◆ map_ptr

pimpl<map> game::map_ptr
private

Definition at line 995 of file game.h.

◆ memorial_logger_ptr

pimpl<memorial_logger> game::memorial_logger_ptr
private

Definition at line 1005 of file game.h.

Referenced by game(), and memorial().

◆ monstairz

int game::monstairz = 0

Definition at line 1032 of file game.h.

Referenced by update_stair_monsters(), and vertical_move().

◆ mostseen

int game::mostseen = 0

◆ moves_since_last_save

int game::moves_since_last_save = 0
private

Definition at line 1088 of file game.h.

Referenced by do_turn(), get_moves_since_last_save(), init_autosave(), quickload(), and quicksave().

◆ new_game

bool game::new_game = false

True if the game has just started or loaded, else false.

Definition at line 1028 of file game.h.

Referenced by do_turn(), setup(), and start_game().

◆ next_mission_id

int game::next_mission_id = 0
private

Definition at line 1086 of file game.h.

Referenced by assign_mission_id(), serialize_master(), setup(), and unserialize_master().

◆ next_npc_id

character_id game::next_npc_id
private

Definition at line 1084 of file game.h.

Referenced by assign_npc_id(), serialize_master(), setup(), and unserialize_master().

◆ npcs_dirty

bool game::npcs_dirty = false
private

Has a NPC been spawned since last load?

Definition at line 1095 of file game.h.

Referenced by do_turn(), load_npcs(), and set_npcs_dirty().

◆ queue_screenshot

bool game::queue_screenshot = false

Definition at line 1067 of file game.h.

Referenced by do_turn().

◆ remoteveh_cache

vehicle* game::remoteveh_cache
private

Definition at line 1093 of file game.h.

Referenced by remoteveh(), setremoteveh(), and setup().

◆ remoteveh_cache_time

time_point game::remoteveh_cache_time
private

Definition at line 1092 of file game.h.

Referenced by remoteveh(), setremoteveh(), and setup().

◆ right_sidebar

bool game::right_sidebar = false

Definition at line 1063 of file game.h.

◆ safe_mode

◆ safe_mode_warning_logged

bool game::safe_mode_warning_logged = false
private

Definition at line 1082 of file game.h.

Referenced by check_safe_mode_allowed(), handle_action(), and set_safe_mode().

◆ scen

const scenario* game::scen

Definition at line 1030 of file game.h.

Referenced by start_calendar(), and start_game().

◆ scent

scent_map& game::scent

Definition at line 1013 of file game.h.

Referenced by display_scent(), do_turn(), serialize(), setup(), unserialize(), update_map(), and vertical_shift().

◆ scent_ptr

pimpl<scent_map> game::scent_ptr
private

Definition at line 999 of file game.h.

◆ seed

unsigned int game::seed = 0
private

Seed for all the random numbers that should have consistent randomness (weather).

Definition at line 1111 of file game.h.

Referenced by get_seed(), serialize_master(), start_game(), and unserialize_master().

◆ sFilter

std::string game::sFilter
private

Definition at line 1078 of file game.h.

Referenced by list_items(), and reset_item_list_state().

◆ show_panel_adm

bool game::show_panel_adm = false

Definition at line 1062 of file game.h.

Referenced by draw_panels(), and load_static_data().

◆ spell_events_ptr

pimpl<spell_events> game::spell_events_ptr
private

Definition at line 1006 of file game.h.

Referenced by game(), and spell_events_subscriber().

◆ stats_tracker_ptr

pimpl<stats_tracker> game::stats_tracker_ptr
private

Definition at line 1002 of file game.h.

Referenced by game(), serialize(), stats(), and unserialize().

◆ ter_view_p

tripoint game::ter_view_p

Definition at line 1034 of file game.h.

Referenced by draw(), and draw_ter().

◆ tileset_zoom

int game::tileset_zoom = 0
private

How far the tileset should be zoomed out, 16 is default.

32 is zoomed in by x2, 8 is zoomed out by x0.5

Definition at line 1108 of file game.h.

Referenced by get_zoom(), look_around(), mouse_edge_scrolling_terrain(), reset_zoom(), set_zoom(), zoom_in(), and zoom_out().

◆ timed_event_manager_ptr

pimpl<timed_event_manager> game::timed_event_manager_ptr
private

Definition at line 1000 of file game.h.

◆ timed_events

timed_event_manager& game::timed_events

Definition at line 1014 of file game.h.

Referenced by do_turn(), natural_light_level(), and setup().

◆ token_provider_ptr

pimpl<drop_token_provider> game::token_provider_ptr

Definition at line 1023 of file game.h.

Referenced by serialize(), setup(), and unserialize().

◆ turnssincelastmon

int game::turnssincelastmon = 0

Definition at line 1069 of file game.h.

Referenced by handle_action(), mon_info_update(), and setup().

◆ u

avatar& game::u

Definition at line 1012 of file game.h.

Referenced by add_npc_follower(), autopilot_vehicles(), cata_event_dispatch::avatar_moves(), butcher(), calc_driving_offset(), cancel_activity_or_ignore_query(), cancel_activity_query(), catch_a_monster(), centerlistview(), chat(), check_safe_mode_allowed(), cleanup_at_end(), control_vehicle(), create_starting_npcs(), critter_at(), critter_by_id(), disable_robot(), disp_NPCs(), display_scent(), do_turn(), draw(), draw_critter(), draw_critter_highlighted(), draw_critter_internal(), draw_hit_mon(), draw_line(), draw_look_around_cursor(), draw_minimap(), draw_panels(), draw_ter(), draw_trail_to_square(), draw_veh_dir_indicator(), drop(), drop_in_direction(), exam_vehicle(), examine(), extended_description(), favorite_ammo_or_select(), find_nearby_items(), find_or_make_stairs(), fling_creature(), forced_door_closing(), fungal_effects::fungalize(), get_dangerous_tile(), get_player_base_save_path(), get_player_input(), get_veh_dir_indicator_location(), grabbed_furn_move(), grabbed_move(), grabbed_veh_move(), handle_action(), handle_key_blocking_activity(), inv_map_splice(), inventory_item_menu(), is_game_over(), is_hostile_within(), is_in_viewport(), item_action_menu(), knockback(), list_items(), list_items_monsters(), list_missions(), list_monsters(), load(), look_around(), mon_info(), mon_info_update(), monmove(), move_save_to_graveyard(), moving_vehicle_dismount(), npc_menu(), on_move_effects(), open_consume_item_menu(), open_gate(), overmap_npc_move(), peek(), perhaps_add_random_npc(), phasing_move(), pickup_feet(), place_player(), place_player_overmap(), print_all_tile_info(), print_creature_info(), print_items_info(), print_terrain_info(), print_trap_info(), process_activity(), process_artifact(), process_voluntary_act_interrupt(), prompt_dangerous_tile(), quickload(), reload(), reload_item(), reload_weapon(), reload_wielded(), remoteveh(), remove_npc_follower(), save(), save_player_data(), serialize(), set_driving_view_offset(), setremoteveh(), shared_from(), slip_down(), fungal_effects::spread_fungus_one_tile(), start_game(), start_hauling(), try_get_left_click_action(), try_get_right_click_action(), unload(), unserialize(), update_map(), update_overmap_seen(), update_stair_monsters(), use_computer(), validate_camps(), validate_npc_followers(), vertical_move(), vertical_notes(), vertical_shift(), walk_move(), wield(), win(), win_screen(), and zones_manager().

◆ u_ptr

pimpl<avatar> game::u_ptr
private

Definition at line 996 of file game.h.

◆ u_shared_ptr

shared_ptr_fast<player> game::u_shared_ptr
private

Definition at line 1073 of file game.h.

Referenced by shared_from().

◆ uquit

quit_status game::uquit

Used in main.cpp to determine what type of quit is being performed.

Definition at line 1026 of file game.h.

Referenced by cleanup_at_end(), do_turn(), get_player_input(), handle_action(), is_game_over(), and setup().

◆ user_action_counter

int game::user_action_counter = 0
private

Definition at line 1105 of file game.h.

Referenced by get_user_action_counter(), and handle_action().

◆ w_minimap

catacurses::window game::w_minimap

Definition at line 1038 of file game.h.

Referenced by create_or_get_main_ui_adaptor(), and draw_minimap().

◆ w_minimap_ptr

catacurses::window game::w_minimap_ptr
private

Definition at line 1076 of file game.h.

Referenced by create_or_get_main_ui_adaptor().

◆ w_omlegend

catacurses::window game::w_omlegend

Definition at line 1037 of file game.h.

◆ w_overmap

catacurses::window game::w_overmap

Definition at line 1036 of file game.h.

◆ w_pixel_minimap

catacurses::window game::w_pixel_minimap

◆ w_terrain

◆ w_terrain_ptr

catacurses::window game::w_terrain_ptr
private

Definition at line 1075 of file game.h.

Referenced by create_or_get_main_ui_adaptor().

◆ wait_popup

std::unique_ptr<static_popup> game::wait_popup
private

Definition at line 1124 of file game.h.

Referenced by do_turn().

◆ was_fullscreen

bool game::was_fullscreen = false

Definition at line 1065 of file game.h.

Referenced by load_static_data(), reenter_fullscreen(), and temp_exit_fullscreen().

◆ weather_manager_ptr

pimpl<weather_manager> game::weather_manager_ptr
private

Definition at line 1008 of file game.h.

◆ zones_manager_open

bool game::zones_manager_open = false
private

Is Zone manager open or not - changes graphics of some zone tiles.

Definition at line 1101 of file game.h.

Referenced by is_zones_manager_open(), and zones_manager().


The documentation for this class was generated from the following files: